@juspay/neurolink 7.11.1 → 7.13.0

package/dist/lib/utils/messageBuilder.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Message Builder Utility
+ * Centralized logic for building message arrays from TextGenerationOptions
+ */
+import type { ChatMessage } from "../types/conversationTypes.js";
+import type { TextGenerationOptions } from "../core/types.js";
+import type { StreamOptions } from "../types/streamTypes.js";
+/**
+ * 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[];

package/dist/lib/utils/messageBuilder.js

@@ -0,0 +1,48 @@
+/**
+ * Message Builder Utility
+ * Centralized logic for building message arrays from TextGenerationOptions
+ */
+import { CONVERSATION_INSTRUCTIONS } from "../config/conversationMemoryConfig.js";
+/**
+ * Build a properly formatted message array for AI providers
+ * Combines system prompt, conversation history, and current user prompt
+ * Supports both TextGenerationOptions and StreamOptions
+ */
+export function buildMessagesArray(options) {
+    const messages = [];
+    // Check if conversation history exists
+    const hasConversationHistory = options.conversationMessages && options.conversationMessages.length > 0;
+    // Build enhanced system prompt
+    let systemPrompt = options.systemPrompt?.trim() || "";
+    // Add conversation-aware instructions when history exists
+    if (hasConversationHistory) {
+        systemPrompt = `${systemPrompt.trim()}${CONVERSATION_INSTRUCTIONS}`;
+    }
+    // Add system message if we have one
+    if (systemPrompt.trim()) {
+        messages.push({
+            role: "system",
+            content: systemPrompt.trim(),
+        });
+    }
+    // Add conversation history if available
+    if (hasConversationHistory && options.conversationMessages) {
+        messages.push(...options.conversationMessages);
+    }
+    // Add current user prompt (required)
+    // Handle both TextGenerationOptions (prompt field) and StreamOptions (input.text field)
+    let currentPrompt;
+    if ("prompt" in options && options.prompt) {
+        currentPrompt = options.prompt;
+    }
+    else if ("input" in options && options.input?.text) {
+        currentPrompt = options.input.text;
+    }
+    if (currentPrompt?.trim()) {
+        messages.push({
+            role: "user",
+            content: currentPrompt.trim(),
+        });
+    }
+    return messages;
+}

package/dist/neurolink.d.ts

@@ -11,6 +11,7 @@ import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { SimpleTool } from "./sdk/toolRegistration.js";
 import type { InMemoryMCPServerConfig } from "./types/mcpTypes.js";
 import { EventEmitter } from "events";
+import type { ConversationMemoryConfig } from "./types/conversationTypes.js";
 export interface ProviderStatus {
     provider: string;
     status: "working" | "failed" | "not-configured";
@@ -40,9 +41,11 @@ export interface MCPServerInfo {
     hasServer: boolean;
     metadata?: unknown;
 }
+import type { ContextManagerConfig } from "./context/types.js";
 export declare class NeuroLink {
     private mcpInitialized;
     private emitter;
+    private contextManager;
     private customTools;
     private inMemoryServers;
     private toolCircuitBreakers;
@@ -55,7 +58,10 @@ export declare class NeuroLink {
      * @param success - Whether the tool execution was successful
      */
     private emitToolEndEvent;
-    constructor();
+    private conversationMemory?;
+    constructor(config?: {
+        conversationMemory?: Partial<ConversationMemoryConfig>;
+    });
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
      * Uses isolated async context to prevent hanging
@@ -65,6 +71,21 @@ export declare class NeuroLink {
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
      */
+    /**
+     * Extracts the original prompt text from the provided input.
+     * If a string is provided, it returns the string directly.
+     * If a GenerateOptions object is provided, it returns the input text from the object.
+     * @param optionsOrPrompt The prompt input, either as a string or a GenerateOptions object.
+     * @returns The original prompt text as a string.
+     */
+    private _extractOriginalPrompt;
+    /**
+     * Enables automatic context summarization for the NeuroLink instance.
+     * Once enabled, the instance will maintain conversation history and
+     * automatically summarize it when it exceeds token limits.
+     * @param config Optional configuration to override default summarization settings.
+     */
+    enableContextSummarization(config?: Partial<ContextManagerConfig>): void;
     generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
     /**
      * BACKWARD COMPATIBILITY: Legacy generateText method
@@ -75,9 +96,11 @@ export declare class NeuroLink {
      * REDESIGNED INTERNAL GENERATION - NO CIRCULAR DEPENDENCIES
      *
      * This method implements a clean fallback chain:
-     * 1. Try MCP-enhanced generation if available
-     * 2. Fall back to direct provider generation
-     * 3. No recursive calls - each method has a specific purpose
+     * 1. Initialize conversation memory if enabled
+     * 2. Inject conversation history into prompt
+     * 3. Try MCP-enhanced generation if available
+     * 4. Fall back to direct provider generation
+     * 5. Store conversation turn for future context
      */
     private generateTextInternal;
     /**
@@ -367,6 +390,18 @@ export declare class NeuroLink {
             recommendations: string[];
         }>;
     };
+    /**
+     * Get conversation memory statistics (public API)
+     */
+    getConversationStats(): Promise<import("./types/conversationTypes.js").ConversationMemoryStats>;
+    /**
+     * Clear conversation history for a specific session (public API)
+     */
+    clearConversationSession(sessionId: string): Promise<boolean>;
+    /**
+     * Clear all conversation history (public API)
+     */
+    clearAllConversations(): Promise<void>;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;

package/dist/neurolink.js

@@ -27,10 +27,15 @@ import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryCon
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { applyConversationMemoryDefaults, getConversationMessages, storeConversationTurn, } from "./utils/conversationMemoryUtils.js";
+import { ContextManager } from "./context/ContextManager.js";
+import { defaultContextConfig } from "./context/config.js";
 // Core types imported from core/types.js
 export class NeuroLink {
     mcpInitialized = false;
     emitter = new EventEmitter();
+    contextManager = null;
     // Tool registration support
     customTools = new Map();
     inMemoryServers = new Map();
@@ -52,11 +57,22 @@ export class NeuroLink {
             timestamp: Date.now(),
         });
     }
-    constructor() {
+    // Conversation memory support
+    conversationMemory;
+    constructor(config) {
         // SDK always disables manual MCP config for security
         ProviderRegistry.setOptions({
             enableManualMCP: false,
         });
+        // Initialize conversation memory if enabled
+        if (config?.conversationMemory?.enabled) {
+            const memoryConfig = applyConversationMemoryDefaults(config.conversationMemory);
+            this.conversationMemory = new ConversationMemoryManager(memoryConfig);
+            logger.info("NeuroLink initialized with conversation memory", {
+                maxSessions: memoryConfig.maxSessions,
+                maxTurnsPerSession: memoryConfig.maxTurnsPerSession,
+            });
+        }
     }
     /**
      * Initialize MCP registry with enhanced error handling and resource cleanup
@@ -107,7 +123,33 @@ export class NeuroLink {
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods
      */
+    /**
+     * Extracts the original prompt text from the provided input.
+     * If a string is provided, it returns the string directly.
+     * If a GenerateOptions object is provided, it returns the input text from the object.
+     * @param optionsOrPrompt The prompt input, either as a string or a GenerateOptions object.
+     * @returns The original prompt text as a string.
+     */
+    _extractOriginalPrompt(optionsOrPrompt) {
+        return typeof optionsOrPrompt === 'string' ? optionsOrPrompt : optionsOrPrompt.input.text;
+    }
+    /**
+     * Enables automatic context summarization for the NeuroLink instance.
+     * Once enabled, the instance will maintain conversation history and
+     * automatically summarize it when it exceeds token limits.
+     * @param config Optional configuration to override default summarization settings.
+     */
+    enableContextSummarization(config) {
+        const contextConfig = {
+            ...defaultContextConfig,
+            ...config,
+        };
+        // Pass the internal generator function directly, bound to the correct `this` context.
+        this.contextManager = new ContextManager(this.generateTextInternal.bind(this), contextConfig);
+        logger.info("[NeuroLink] Automatic context summarization enabled.");
+    }
     async generate(optionsOrPrompt) {
+        const originalPrompt = this._extractOriginalPrompt(optionsOrPrompt);
         // Convert string prompt to full options
         const options = typeof optionsOrPrompt === "string"
             ? { input: { text: optionsOrPrompt } }
@@ -116,6 +158,11 @@ export class NeuroLink {
         if (!options.input?.text || typeof options.input.text !== "string") {
             throw new Error("Input text is required and must be a non-empty string");
         }
+        // Handle Context Management if enabled
+        if (this.contextManager) {
+            // Get the full context for the prompt without permanently adding the user's turn yet
+            options.input.text = this.contextManager.getContextForPrompt("user", options.input.text);
+        }
         const startTime = Date.now();
         // Emit generation start event
         this.emitter.emit("generation:start", {
@@ -227,6 +274,11 @@ export class NeuroLink {
                 }
                 : undefined,
         };
+        // Add both the user's turn and the AI's response to the permanent history
+        if (this.contextManager) {
+            await this.contextManager.addTurn("user", originalPrompt);
+            await this.contextManager.addTurn("assistant", generateResult.content);
+        }
         return generateResult;
     }
     /**
@@ -247,9 +299,11 @@ export class NeuroLink {
      * REDESIGNED INTERNAL GENERATION - NO CIRCULAR DEPENDENCIES
      *
      * This method implements a clean fallback chain:
-     * 1. Try MCP-enhanced generation if available
-     * 2. Fall back to direct provider generation
-     * 3. No recursive calls - each method has a specific purpose
+     * 1. Initialize conversation memory if enabled
+     * 2. Inject conversation history into prompt
+     * 3. Try MCP-enhanced generation if available
+     * 4. Fall back to direct provider generation
+     * 5. Store conversation turn for future context
      */
     async generateTextInternal(options) {
         const startTime = Date.now();
@@ -257,14 +311,21 @@ export class NeuroLink {
         logger.debug(`[${functionTag}] Starting generation`, {
             provider: options.provider || "auto",
             promptLength: options.prompt?.length || 0,
+            hasConversationMemory: !!this.conversationMemory,
         });
         try {
+            // Initialize conversation memory if enabled
+            if (this.conversationMemory) {
+                await this.conversationMemory.initialize();
+            }
             // Try MCP-enhanced generation first (if not explicitly disabled)
             if (!options.disableTools) {
                 try {
                     const mcpResult = await this.tryMCPGeneration(options);
                     if (mcpResult && mcpResult.content) {
                         logger.debug(`[${functionTag}] MCP generation successful`);
+                        // Store conversation turn
+                        await storeConversationTurn(this.conversationMemory, options, mcpResult);
                         return mcpResult;
                     }
                 }
@@ -277,6 +338,8 @@ export class NeuroLink {
             // Fall back to direct provider generation
             const directResult = await this.directProviderGeneration(options);
             logger.debug(`[${functionTag}] Direct generation successful`);
+            // Store conversation turn
+            await storeConversationTurn(this.conversationMemory, options, directResult);
             return directResult;
         }
         catch (error) {
@@ -334,6 +397,8 @@ export class NeuroLink {
             }
             // Create tool-aware system prompt
             const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
+            // Get conversation messages for context
+            const conversationMessages = await getConversationMessages(this.conversationMemory, options);
             // Create provider and generate
             const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
             this);
@@ -345,6 +410,7 @@ export class NeuroLink {
             const result = await provider.generate({
                 ...options,
                 systemPrompt: enhancedSystemPrompt,
+                conversationMessages, // Inject conversation history
             });
             const responseTime = Date.now() - startTime;
             // Check if result is meaningful
@@ -413,6 +479,8 @@ export class NeuroLink {
         for (const providerName of tryProviders) {
             try {
                 logger.debug(`[${functionTag}] Attempting provider: ${providerName}`);
+                // Get conversation messages for context
+                const conversationMessages = await getConversationMessages(this.conversationMemory, options);
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
                 this);
                 // Enable tool execution for direct provider generation using BaseProvider method
@@ -420,7 +488,10 @@ export class NeuroLink {
                     customTools: this.customTools,
                     executeTool: this.executeTool.bind(this),
                 }, functionTag);
-                const result = await provider.generate(options);
+                const result = await provider.generate({
+                    ...options,
+                    conversationMessages, // Inject conversation history
+                });
                 const responseTime = Date.now() - startTime;
                 if (!result) {
                     throw new Error(`Provider ${providerName} returned null result`);
@@ -1577,6 +1648,36 @@ export class NeuroLink {
             tools,
         };
     }
+    // ============================================================================
+    // CONVERSATION MEMORY PUBLIC API
+    // ============================================================================
+    /**
+     * Get conversation memory statistics (public API)
+     */
+    async getConversationStats() {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        return await this.conversationMemory.getStats();
+    }
+    /**
+     * Clear conversation history for a specific session (public API)
+     */
+    async clearConversationSession(sessionId) {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        return await this.conversationMemory.clearSession(sessionId);
+    }
+    /**
+     * Clear all conversation history (public API)
+     */
+    async clearAllConversations() {
+        if (!this.conversationMemory) {
+            throw new Error("Conversation memory is not enabled");
+        }
+        await this.conversationMemory.clearAllSessions();
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/providers/amazonBedrock.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createAWSAccessKeyConfig, createAWSSecretConfig, getAWSRegion, getAWSSessionToken, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers
 const getBedrockModelId = () => {
     return (process.env.BEDROCK_MODEL ||
@@ -79,10 +80,11 @@ export class AmazonBedrockProvider extends BaseProvider {
     async executeStream(options, analysisSchema) {
         try {
             this.validateStreamOptions(options);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 temperature: options.temperature,
             });

package/dist/providers/anthropic.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
     return validateApiKey(createAnthropicConfig());
@@ -94,10 +95,11 @@ export class AnthropicProvider extends BaseProvider {
             // ✅ Get tools for streaming (same as generate method)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt || undefined,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/providers/azureOpenai.js

@@ -3,6 +3,7 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } from "../utils/providerConfig.js";
 import { logger } from "../utils/logger.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 export class AzureOpenAIProvider extends BaseProvider {
     apiKey;
     resourceName;
@@ -69,12 +70,13 @@ export class AzureOpenAIProvider extends BaseProvider {
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {
         try {
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const stream = await streamText({
                 model: this.azureProvider(this.deployment),
-                prompt: options.input?.text || "",
+                messages: messages,
                 maxTokens: options.maxTokens || 1000,
                 temperature: options.temperature || 0.7,
-                system: options.systemPrompt,
             });
             return {
                 stream: (async function* () {

package/dist/providers/googleAiStudio.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
     process.env.GOOGLE_AI_API_KEY) {
@@ -76,10 +77,11 @@ export class GoogleAIStudioProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/providers/googleVertex.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Cache for anthropic module to avoid repeated imports
 let _createVertexAnthropic = null;
 let _anthropicImportAttempted = false;
@@ -189,6 +190,8 @@ export class GoogleVertexProvider extends BaseProvider {
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             this.validateStreamOptions(options);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             logger.debug(`${functionTag}: Starting stream request`, {
                 modelName: this.modelName,
                 promptLength: options.input.text.length,
@@ -209,8 +212,7 @@ export class GoogleVertexProvider extends BaseProvider {
             // Build complete stream options with proper typing
             let streamOptions = {
                 model: model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 ...(maxTokens && { maxTokens }),
                 tools,

package/dist/providers/huggingFace.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getHuggingFaceApiKey = () => {
     return validateApiKey(createHuggingFaceConfig());
@@ -111,10 +112,11 @@ export class HuggingFaceProvider extends BaseProvider {
         try {
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: streamOptions.prompt,
-                system: streamOptions.system,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions

package/dist/providers/litellm.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
     return {
@@ -118,10 +119,11 @@ export class LiteLLMProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools: options.tools,

package/dist/providers/mistral.js

@@ -6,6 +6,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
@@ -46,10 +47,10 @@ export class MistralProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,

package/dist/providers/openAI.js

@@ -7,6 +7,7 @@ import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
+import { buildMessagesArray } from "../utils/messageBuilder.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -77,10 +78,11 @@ export class OpenAIProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
+            // Build message array from options
+            const messages = buildMessagesArray(options);
             const result = await streamText({
                 model: this.model,
-                prompt: options.input.text,
-                system: options.systemPrompt,
+                messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 tools,