@juspay/neurolink 7.37.1 → 7.38.0

package/dist/lib/utils/redis.js

@@ -53,123 +53,120 @@ export async function createRedisClient(config) {
 /**
  * Generates a Redis key for session messages
  */
-export function getSessionKey(config, sessionId) {
-    const key = `${config.keyPrefix}${sessionId}`;
+export function getSessionKey(config, sessionId, userId) {
+    const key = `${config.keyPrefix}${userId || "randomUser"}:${sessionId}`;
     logger.debug("[redisUtils] Generated session key", {
         sessionId,
+        userId,
         keyPrefix: config.keyPrefix,
         fullKey: key,
     });
     return key;
 }
 /**
- * Serializes messages for Redis storage
+ * Generates a Redis key for user sessions mapping
  */
-export function serializeMessages(messages) {
+export function getUserSessionsKey(config, userId) {
+    return `${config.userSessionsKeyPrefix}${userId}`;
+}
+/**
+ * Serializes conversation object for Redis storage
+ */
+export function serializeConversation(conversation) {
     try {
-        logger.debug("[redisUtils] Serializing messages", {
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
-        });
-        const serialized = JSON.stringify(messages);
-        logger.debug("[redisUtils] Messages serialized successfully", {
-            serializedLength: serialized.length,
-            messageCount: messages.length,
-        });
+        const serialized = JSON.stringify(conversation);
         return serialized;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to serialize messages", {
+        logger.error("[redisUtils] Failed to serialize conversation", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
-            messageCount: messages.length,
+            sessionId: conversation?.sessionId,
+            userId: conversation?.userId,
         });
         throw error;
     }
 }
 /**
- * Deserializes messages from Redis storage
+ * Deserializes conversation object from Redis storage
  */
-export function deserializeMessages(data) {
+export function deserializeConversation(data) {
     if (!data) {
-        logger.debug("[redisUtils] No data to deserialize, returning empty array");
-        return [];
+        logger.debug("[redisUtils] No conversation data to deserialize, returning null");
+        return null;
     }
     try {
-        logger.debug("[redisUtils] Deserializing messages", {
+        logger.debug("[redisUtils] Deserializing conversation", {
             dataLength: data.length,
             dataPreview: data.substring(0, 100) + (data.length > 100 ? "..." : ""),
         });
         // Parse as unknown first, then validate before casting
         const parsedData = JSON.parse(data);
-        // Check if the parsed data is an array
-        if (!Array.isArray(parsedData)) {
-            logger.warn("[redisUtils] Deserialized data is not an array", {
+        // Check if the parsed data is an object with required properties
+        if (typeof parsedData !== "object" ||
+            parsedData === null ||
+            !("title" in parsedData) ||
+            !("sessionId" in parsedData) ||
+            !("userId" in parsedData) ||
+            !("createdAt" in parsedData) ||
+            !("updatedAt" in parsedData) ||
+            !("messages" in parsedData)) {
+            logger.warn("[redisUtils] Deserialized data is not a valid conversation object", {
                 type: typeof parsedData,
+                hasRequiredFields: parsedData && typeof parsedData === "object"
+                    ? Object.keys(parsedData).join(", ")
+                    : "none",
                 preview: JSON.stringify(parsedData).substring(0, 100),
             });
-            return [];
+            return null;
+        }
+        const conversation = parsedData;
+        // Validate messages is an array
+        if (!Array.isArray(conversation.messages)) {
+            logger.warn("[redisUtils] messages is not an array", {
+                type: typeof conversation.messages,
+            });
+            return null;
         }
-        // Validate each item in the array has the correct ChatMessage structure
-        const isValid = parsedData.every((m) => typeof m === "object" &&
+        // Validate each message in the messages array
+        const isValidHistory = conversation.messages.every((m) => typeof m === "object" &&
             m !== null &&
             "role" in m &&
             "content" in m &&
             typeof m.role === "string" &&
             typeof m.content === "string" &&
-            (m.role === "user" || m.role === "assistant" || m.role === "system"));
-        if (!isValid) {
-            logger.warn("[redisUtils] Deserialized data has unexpected structure", {
-                isArray: true,
-                firstItem: parsedData.length > 0 ? JSON.stringify(parsedData[0]) : null,
+            (m.role === "user" ||
+                m.role === "assistant" ||
+                m.role === "system" ||
+                m.role === "tool_call" ||
+                m.role === "tool_result"));
+        if (!isValidHistory) {
+            logger.warn("[redisUtils] Invalid messages structure", {
+                messageCount: conversation.messages.length,
+                firstMessage: conversation.messages.length > 0
+                    ? JSON.stringify(conversation.messages[0])
+                    : null,
             });
-            return [];
+            return null;
         }
-        // Now that we've validated, we can safely cast
-        const messages = parsedData;
-        logger.debug("[redisUtils] Messages deserialized successfully", {
-            messageCount: messages.length,
-            messageTypes: messages.map((m) => m.role),
-            firstMessage: messages.length > 0
-                ? {
-                    role: messages[0].role,
-                    contentLength: messages[0].content.length,
-                    contentPreview: messages[0].content.substring(0, 50),
-                }
-                : null,
-            lastMessage: messages.length > 0
-                ? {
-                    role: messages[messages.length - 1].role,
-                    contentLength: messages[messages.length - 1].content.length,
-                    contentPreview: messages[messages.length - 1].content.substring(0, 50),
-                }
-                : null,
+        logger.debug("[redisUtils] Conversation deserialized successfully", {
+            sessionId: conversation.sessionId,
+            userId: conversation.userId,
+            title: conversation.title,
+            messageCount: conversation.messages.length,
+            createdAt: conversation.createdAt,
+            updatedAt: conversation.updatedAt,
         });
-        logger.debug("[deserializeMessages] completed");
-        return messages;
+        return conversation;
     }
     catch (error) {
-        logger.error("[redisUtils] Failed to deserialize messages", {
+        logger.error("[redisUtils] Failed to deserialize conversation", {
             error: error instanceof Error ? error.message : String(error),
             stack: error instanceof Error ? error.stack : undefined,
             dataLength: data.length,
             dataPreview: "[REDACTED]", // Prevent exposure of potentially sensitive data
         });
-        return [];
+        return null;
     }
 }
 /**
@@ -245,12 +242,16 @@ export async function scanKeys(client, pattern, batchSize = 100) {
  * Get normalized Redis configuration with defaults
  */
 export function getNormalizedConfig(config) {
+    const keyPrefix = config.keyPrefix || "neurolink:conversation:";
+    // Intelligent default: derive user sessions prefix from conversation prefix
+    const defaultUserSessionsPrefix = keyPrefix.replace(/conversation:?$/, "user:sessions:");
     return {
         host: config.host || "localhost",
         port: config.port || 6379,
         password: config.password || "",
         db: config.db || 0,
-        keyPrefix: config.keyPrefix || "neurolink:conversation:",
+        keyPrefix,
+        userSessionsKeyPrefix: config.userSessionsKeyPrefix || defaultUserSessionsPrefix,
         ttl: config.ttl || 86400,
         connectionOptions: {
             connectTimeout: 30000,

package/dist/neurolink.d.ts

@@ -14,6 +14,8 @@ import type { NeuroLinkEvents, TypedEventEmitter, ToolExecutionContext, ToolExec
 import type { JsonObject } from "./types/common.js";
 import type { BatchOperationResult } from "./types/typeAliases.js";
 import type { ConversationMemoryConfig, ChatMessage } from "./types/conversation.js";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
 export interface ProviderStatus {
     provider: string;
@@ -62,7 +64,7 @@ export declare class NeuroLink {
      * @param error - The error if execution failed (optional)
      */
     private emitToolEndEvent;
-    private conversationMemory?;
+    conversationMemory?: ConversationMemoryManager | RedisConversationMemoryManager | null;
     private conversationMemoryNeedsInit;
     private conversationMemoryConfig?;
     private enableOrchestration;
@@ -848,6 +850,12 @@ export declare class NeuroLink {
             recommendations: string[];
         }>;
     }>;
+    /**
+     * Initialize conversation memory if enabled (public method for explicit initialization)
+     * This is useful for testing or when you want to ensure conversation memory is ready
+     * @returns Promise resolving to true if initialization was successful, false otherwise
+     */
+    ensureConversationMemoryInitialized(): Promise<boolean>;
     /**
      * Get conversation memory statistics (public API)
      */
@@ -866,6 +874,30 @@ export declare class NeuroLink {
      * Clear all conversation history (public API)
      */
     clearAllConversations(): Promise<void>;
+    /**
+     * Store tool executions in conversation memory if enabled and Redis is configured
+     * @param sessionId - Session identifier
+     * @param userId - User identifier (optional)
+     * @param toolCalls - Array of tool calls
+     * @param toolResults - Array of tool results
+     * @returns Promise resolving when storage is complete
+     */
+    storeToolExecutions(sessionId: string, userId: string | undefined, toolCalls: Array<{
+        toolCallId?: string;
+        toolName?: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>, toolResults: Array<{
+        toolCallId?: string;
+        result?: unknown;
+        error?: string;
+        [key: string]: unknown;
+    }>): Promise<void>;
+    /**
+     * Check if tool execution storage is available
+     * @returns boolean indicating if Redis storage is configured and available
+     */
+    isToolExecutionStorageAvailable(): boolean;
     /**
      * Add an external MCP server
      * Automatically discovers and registers tools from the server

package/dist/neurolink.js

@@ -3232,6 +3232,24 @@ export class NeuroLink {
     // ============================================================================
     // CONVERSATION MEMORY PUBLIC API
     // ============================================================================
+    /**
+     * Initialize conversation memory if enabled (public method for explicit initialization)
+     * This is useful for testing or when you want to ensure conversation memory is ready
+     * @returns Promise resolving to true if initialization was successful, false otherwise
+     */
+    async ensureConversationMemoryInitialized() {
+        try {
+            const initId = `manual-init-${Date.now()}`;
+            await this.initializeConversationMemoryForGeneration(initId, Date.now(), process.hrtime.bigint());
+            return !!this.conversationMemory;
+        }
+        catch (error) {
+            logger.error("Failed to initialize conversation memory", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return false;
+        }
+    }
     /**
      * Get conversation memory statistics (public API)
      */
@@ -3302,6 +3320,52 @@ export class NeuroLink {
         }
         await this.conversationMemory.clearAllSessions();
     }
+    /**
+     * Store tool executions in conversation memory if enabled and Redis is configured
+     * @param sessionId - Session identifier
+     * @param userId - User identifier (optional)
+     * @param toolCalls - Array of tool calls
+     * @param toolResults - Array of tool results
+     * @returns Promise resolving when storage is complete
+     */
+    async storeToolExecutions(sessionId, userId, toolCalls, toolResults) {
+        // Check if tools are not empty
+        const hasToolData = (toolCalls && toolCalls.length > 0) ||
+            (toolResults && toolResults.length > 0);
+        if (!hasToolData) {
+            logger.debug("Tool execution storage skipped", {
+                hasToolData,
+                toolCallsCount: toolCalls?.length || 0,
+                toolResultsCount: toolResults?.length || 0,
+            });
+            return;
+        }
+        // Type guard to ensure it's Redis conversation memory manager
+        const redisMemory = this
+            .conversationMemory;
+        try {
+            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults);
+        }
+        catch (error) {
+            logger.warn("Failed to store tool executions", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't throw - tool storage failures shouldn't break generation
+        }
+    }
+    /**
+     * Check if tool execution storage is available
+     * @returns boolean indicating if Redis storage is configured and available
+     */
+    isToolExecutionStorageAvailable() {
+        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
+        const hasRedisConversationMemory = this.conversationMemory &&
+            this.conversationMemory.constructor.name ===
+                "RedisConversationMemoryManager";
+        return !!(isRedisStorage && hasRedisConversationMemory);
+    }
     // ===== EXTERNAL MCP SERVER METHODS =====
     /**
      * Add an external MCP server

package/dist/providers/anthropic.js

@@ -103,6 +103,14 @@ export class AnthropicProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             const transformedStream = this.createTextStream(result);

package/dist/providers/anthropicBaseProvider.js

@@ -73,6 +73,14 @@ export class AnthropicProviderV2 extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream (match Google AI pattern)

package/dist/providers/azureOpenai.js

@@ -122,6 +122,14 @@ export class AzureOpenAIProvider extends BaseProvider {
                     : {}),
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             });
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/googleAiStudio.js

@@ -101,6 +101,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/googleVertex.js

@@ -646,6 +646,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 onChunk: () => {
                     chunkCount++;
                 },
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
+                    // Handle tool execution storage
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             };
             if (analysisSchema) {
                 try {

package/dist/providers/huggingFace.js

@@ -123,6 +123,14 @@ export class HuggingFaceProvider extends BaseProvider {
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
                 toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[HuggingFaceProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface with enhanced tool call parsing

package/dist/providers/litellm.js

@@ -130,6 +130,14 @@ export class LiteLLMProvider extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("LiteLLMProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface

package/dist/providers/mistral.js

@@ -59,6 +59,14 @@ export class MistralProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[MistralProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/openAI.js

@@ -272,6 +272,16 @@ export class OpenAIProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
+                    // Handle tool execution storage
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[OpenAIProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Debug the actual result structure

package/dist/providers/openaiCompatible.js

@@ -166,6 +166,14 @@ export class OpenAICompatibleProvider extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[OpenAiCompatibleProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface

package/dist/types/conversation.d.ts

@@ -32,6 +32,8 @@ export interface SessionMemory {
     sessionId: string;
     /** User identifier (optional) */
     userId?: string;
+    /** Auto-generated conversation title (created on first user message) */
+    title?: string;
     /** Direct message storage - ready for immediate AI consumption */
     messages: ChatMessage[];
     /** When this session was created */
@@ -61,10 +63,26 @@ export interface ConversationMemoryStats {
  * Chat message format for conversation history
  */
 export interface ChatMessage {
-    /** Role of the message sender */
-    role: "user" | "assistant" | "system";
+    /** Role/type of the message */
+    role: "user" | "assistant" | "system" | "tool_call" | "tool_result";
     /** Content of the message */
     content: string;
+    /** Message ID (optional) - for new format */
+    id?: string;
+    /** Timestamp (optional) - for new format */
+    timestamp?: string;
+    /** Tool name (optional) - for tool_call/tool_result messages */
+    tool?: string;
+    /** Tool arguments (optional) - for tool_call messages */
+    args?: Record<string, unknown>;
+    /** Tool result (optional) - for tool_result messages */
+    result?: {
+        success?: boolean;
+        expression?: string;
+        result?: unknown;
+        type?: string;
+        error?: string;
+    };
 }
 /**
  * Content format for multimodal messages (used internally)
@@ -129,6 +147,36 @@ export type SessionIdentifier = {
     sessionId: string;
     userId?: string;
 };
+/**
+ * Lightweight session metadata for efficient session listing
+ * Contains only essential information without heavy message arrays
+ */
+export interface SessionMetadata {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * New Redis conversation storage object format
+ * Contains conversation metadata and history in a single object
+ */
+export type RedisConversationObject = {
+    /** Unique conversation identifier (UUID v4) */
+    id: string;
+    /** Auto-generated conversation title */
+    title: string;
+    /** Session identifier */
+    sessionId: string;
+    /** User identifier */
+    userId: string;
+    /** When this conversation was first created */
+    createdAt: string;
+    /** When this conversation was last updated */
+    updatedAt: string;
+    /** Array of conversation messages */
+    messages: ChatMessage[];
+};
 /**
  * Redis storage configuration
  */
@@ -143,6 +191,8 @@ export type RedisStorageConfig = {
     db?: number;
     /** Key prefix for Redis keys (default: 'neurolink:conversation:') */
     keyPrefix?: string;
+    /** Key prefix for user sessions mapping (default: derived from keyPrefix) */
+    userSessionsKeyPrefix?: string;
     /** Time-to-live in seconds (default: 86400, 24 hours) */
     ttl?: number;
     /** Additional Redis connection options */

package/dist/utils/conversationMemory.js

@@ -32,8 +32,10 @@ export async function getConversationMessages(conversationMemory, options) {
         return [];
     }
     try {
+        // Extract userId from context
+        const userId = options.context?.userId;
         // Remove duplicate summarization logic - it should be handled in ConversationMemoryManager
-        const messages = await conversationMemory.buildContextMessages(sessionId);
+        const messages = await conversationMemory.buildContextMessages(sessionId, userId);
         logger.debug("[conversationMemoryUtils] Conversation messages retrieved successfully", {
             sessionId,
             messageCount: messages.length,

package/dist/utils/messageBuilder.d.ts

@@ -3,18 +3,26 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
-import type { ChatMessage, MultimodalChatMessage } from "../types/conversation.js";
+import type { MultimodalChatMessage } from "../types/conversation.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 import type { GenerateOptions } from "../types/generateTypes.js";
+/**
+ * Core message type compatible with AI SDK
+ */
+type CoreMessage = {
+    role: "user" | "assistant" | "system";
+    content: string;
+};
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
  */
-export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): ChatMessage[];
+export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): CoreMessage[];
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter
  */
 export declare function buildMultimodalMessagesArray(options: GenerateOptions, provider: string, model: string): Promise<MultimodalChatMessage[]>;
+export {};