@juspay/neurolink 7.29.2 → 7.30.0

package/dist/utils/providerHealth.js

@@ -445,265 +445,210 @@ export class ProviderHealthChecker {
      */
     static async checkProviderSpecificConfig(providerName, healthStatus) {
         switch (providerName) {
-            case AIProviderName.VERTEX: {
-                logger.debug("Starting Vertex AI health check", {
-                    providerName,
-                });
-                // Check for Google Cloud project ID (with fallbacks)
-                const projectId = process.env.GOOGLE_PROJECT_ID ||
-                    process.env.GOOGLE_CLOUD_PROJECT_ID ||
-                    process.env.GOOGLE_VERTEX_PROJECT ||
-                    process.env.GOOGLE_CLOUD_PROJECT ||
-                    process.env.VERTEX_PROJECT_ID;
-                logger.debug("Project ID validation", {
-                    hasProjectId: !!projectId,
-                });
-                if (!projectId) {
-                    healthStatus.configurationIssues.push("Google Cloud project ID not set");
-                    healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
-                }
-                // Check for authentication with proper file existence validation
-                // This aligns with the authentication logic fix in googleVertex.ts
-                let hasValidAuth = false;
-                logger.debug("Authentication validation starting", {
-                    hasGoogleApplicationCredentials: !!process.env.GOOGLE_APPLICATION_CREDENTIALS,
-                });
-                // Check for principal account authentication first (recommended for production)
-                // BUT CRITICALLY: Also verify the file actually exists
-                if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
-                    const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-                    logger.debug("Checking GOOGLE_APPLICATION_CREDENTIALS file");
-                    // Check if the credentials file actually exists
-                    let fileExists = false;
-                    try {
-                        const { promises: fs } = await import("fs");
-                        try {
-                            await fs.access(credentialsPath);
-                            fileExists = true;
-                        }
-                        catch {
-                            fileExists = false;
-                        }
-                        logger.debug("File existence check completed", {
-                            fileExists,
-                        });
-                    }
-                    catch (error) {
-                        logger.debug("File existence check failed", {
-                            error: String(error),
-                        });
-                        healthStatus.warning = `Failed to check credentials file existence: ${error}`;
-                        fileExists = false;
-                    }
-                    if (fileExists) {
-                        // Validate file format
-                        const fileName = basename(credentialsPath);
-                        const jsonFilePattern = /\.json(\.\w+)?$/;
-                        if (!jsonFilePattern.test(fileName)) {
-                            healthStatus.warning =
-                                "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file (e.g., 'credentials.json' or 'key.json.backup')";
-                        }
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file validated", {
-                            fileName,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
-                        logger.debug("GOOGLE_APPLICATION_CREDENTIALS file missing, falling back to individual env vars");
-                        // Fall through to check individual environment variables
-                    }
-                }
-                else {
-                    logger.debug("GOOGLE_APPLICATION_CREDENTIALS not set, checking individual env vars");
-                }
-                // Fallback to individual credentials for development and production
-                // Enhanced to check ALL required fields from the .env file configuration
-                if (!hasValidAuth) {
-                    const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
-                    const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
-                        process.env.GOOGLE_AUTH_PRIVATE_KEY);
-                    logger.debug("Individual credentials check", {
-                        hasServiceAccountKey,
-                        hasGoogleAuthClientEmail: !!process.env.GOOGLE_AUTH_CLIENT_EMAIL,
-                        hasGoogleAuthPrivateKey: !!process.env.GOOGLE_AUTH_PRIVATE_KEY,
-                        hasIndividualCredentials,
-                    });
-                    if (hasServiceAccountKey || hasIndividualCredentials) {
-                        hasValidAuth = true;
-                        healthStatus.hasApiKey = true;
-                        logger.debug("Individual credentials validated successfully", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                            hasValidAuth,
-                        });
-                    }
-                    else {
-                        logger.debug("Individual credentials validation failed", {
-                            hasServiceAccountKey,
-                            hasIndividualCredentials,
-                        });
-                    }
-                }
-                // Final validation
-                if (!hasValidAuth) {
-                    healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
-                    healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
-                    logger.debug("Final auth validation FAILED", {
-                        hasValidAuth,
-                    });
-                }
-                else {
-                    logger.debug("Final auth validation SUCCESS", {
-                        hasValidAuth,
-                    });
-                }
-                // Mark as configured if we have both project ID and auth
-                if (projectId && hasValidAuth) {
-                    healthStatus.isConfigured = true;
-                    logger.debug("Vertex AI health check PASSED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
-                else {
-                    logger.debug("Vertex AI health check FAILED", {
-                        hasProjectId: !!projectId,
-                        hasValidAuth,
-                        isConfigured: healthStatus.isConfigured,
-                    });
-                }
+            case AIProviderName.VERTEX:
+                await this.checkVertexAIConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.BEDROCK: {
-                logger.debug("Starting AWS Bedrock comprehensive health check", {
-                    providerName,
-                });
-                // Check AWS region configuration
-                const awsRegion = process.env.AWS_REGION;
-                const validBedrockRegions = [
-                    "us-east-1",
-                    "us-west-2",
-                    "ap-southeast-1",
-                    "ap-northeast-1",
-                    "eu-central-1",
-                    "eu-west-1",
-                    "ap-south-1",
-                ];
-                logger.debug("AWS Region validation", {
-                    hasAwsRegion: !!awsRegion,
-                    awsRegion: awsRegion || "not set",
-                    validBedrockRegions,
-                });
-                if (!awsRegion) {
-                    healthStatus.configurationIssues.push("AWS_REGION not set");
-                    healthStatus.recommendations.push(`Set AWS_REGION to a Bedrock-supported region: ${validBedrockRegions.join(", ")}`);
-                }
-                else if (!validBedrockRegions.includes(awsRegion)) {
-                    healthStatus.configurationIssues.push(`AWS_REGION '${awsRegion}' may not support all Bedrock models`);
-                    healthStatus.recommendations.push(`Consider using a primary Bedrock region: ${validBedrockRegions.slice(0, 3).join(", ")}`);
-                }
-                // Check AWS credentials configuration
-                const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
-                const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
-                const awsSessionToken = process.env.AWS_SESSION_TOKEN;
-                const awsProfile = process.env.AWS_PROFILE;
-                logger.debug("AWS Credentials validation", {
-                    hasAccessKeyId: !!awsAccessKeyId,
-                    hasSecretAccessKey: !!awsSecretAccessKey,
-                    hasSessionToken: !!awsSessionToken,
-                    hasProfile: !!awsProfile,
-                    authMethod: awsProfile
-                        ? "AWS Profile"
-                        : awsAccessKeyId
-                            ? "Access Keys"
-                            : "None detected",
-                });
-                if (!awsAccessKeyId && !awsProfile) {
-                    healthStatus.configurationIssues.push("No AWS credentials found");
-                    healthStatus.recommendations.push("Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or configure AWS_PROFILE");
-                }
-                else if (awsAccessKeyId && !awsSecretAccessKey) {
-                    healthStatus.configurationIssues.push("AWS_ACCESS_KEY_ID set but AWS_SECRET_ACCESS_KEY missing");
-                    healthStatus.recommendations.push("Set AWS_SECRET_ACCESS_KEY to match your AWS_ACCESS_KEY_ID");
-                }
-                // Check for Bedrock-specific model configuration
-                const bedrockModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
-                const supportedModels = [
-                    "anthropic.claude-3-sonnet-20240229-v1:0",
-                    "anthropic.claude-3-haiku-20240307-v1:0",
-                    "anthropic.claude-3-opus-20240229-v1:0",
-                    "anthropic.claude-v2:1",
-                    "amazon.titan-text-express-v1",
-                ];
-                logger.debug("Bedrock Model validation", {
-                    hasBedrockModel: !!bedrockModel,
-                    bedrockModel: bedrockModel || "not set",
-                    supportedModels: supportedModels.slice(0, 3),
-                });
-                if (!bedrockModel) {
-                    healthStatus.recommendations.push("Set BEDROCK_MODEL or BEDROCK_MODEL_ID for faster startup (e.g., anthropic.claude-3-sonnet-20240229-v1:0)");
-                }
-                else if (!supportedModels.some((model) => model === bedrockModel)) {
-                    healthStatus.recommendations.push(`Consider using a popular Bedrock model: ${supportedModels.slice(0, 3).join(", ")}`);
-                }
-                // Check for additional Bedrock configuration
-                const bedrockEndpoint = process.env.BEDROCK_ENDPOINT_URL;
-                if (bedrockEndpoint) {
-                    logger.debug("Custom Bedrock endpoint detected", {
-                        endpoint: bedrockEndpoint,
-                    });
-                    if (!bedrockEndpoint.startsWith("https://")) {
-                        healthStatus.configurationIssues.push("BEDROCK_ENDPOINT_URL should use HTTPS");
-                        healthStatus.recommendations.push("Update BEDROCK_ENDPOINT_URL to use HTTPS protocol");
-                    }
-                }
-                // AWS SDK Configuration checks
-                const awsConfig = {
-                    maxAttempts: process.env.AWS_MAX_ATTEMPTS,
-                    retryMode: process.env.AWS_RETRY_MODE,
-                    defaultsMode: process.env.AWS_DEFAULTS_MODE,
-                };
-                logger.debug("AWS SDK Configuration", {
-                    awsConfig,
-                    hasAdvancedConfig: Object.values(awsConfig).some(Boolean),
-                });
-                if (healthStatus.configurationIssues.length === 0) {
-                    healthStatus.hasApiKey = true;
-                    logger.debug("AWS Bedrock configuration appears valid", {
-                        region: awsRegion,
-                        hasCredentials: !!(awsAccessKeyId || awsProfile),
-                        hasModel: !!bedrockModel,
-                    });
-                }
+            case AIProviderName.BEDROCK:
+                await this.checkBedrockConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.AZURE: {
-                // Check Azure OpenAI endpoint
-                const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
-                if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
-                    healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
-                }
-                // Check for deployment name
-                if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
-                    healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
-                    healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
-                }
+            case AIProviderName.AZURE:
+                await this.checkAzureConfig(healthStatus);
                 break;
-            }
-            case AIProviderName.OLLAMA: {
-                // Check if custom endpoint is set
-                const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
-                if (!ollamaBase.startsWith("http")) {
-                    healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
-                    healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
-                }
+            case AIProviderName.OLLAMA:
+                await this.checkOllamaConfig(healthStatus);
                 break;
+        }
+    }
+    /**
+     * Check Vertex AI configuration
+     */
+    static async checkVertexAIConfig(healthStatus) {
+        logger.debug("Starting Vertex AI health check");
+        const projectId = this.getVertexProjectId();
+        if (!projectId) {
+            healthStatus.configurationIssues.push("Google Cloud project ID not set");
+            healthStatus.recommendations.push("Set one of: GOOGLE_VERTEX_PROJECT, GOOGLE_CLOUD_PROJECT_ID, GOOGLE_PROJECT_ID, or GOOGLE_CLOUD_PROJECT");
+        }
+        const hasValidAuth = await this.checkVertexAuthentication(healthStatus);
+        if (projectId && hasValidAuth) {
+            healthStatus.isConfigured = true;
+            logger.debug("Vertex AI health check PASSED");
+        }
+        else {
+            logger.debug("Vertex AI health check FAILED");
+        }
+    }
+    /**
+     * Get Vertex AI project ID from environment variables
+     */
+    static getVertexProjectId() {
+        return (process.env.GOOGLE_PROJECT_ID ||
+            process.env.GOOGLE_CLOUD_PROJECT_ID ||
+            process.env.GOOGLE_VERTEX_PROJECT ||
+            process.env.GOOGLE_CLOUD_PROJECT ||
+            process.env.VERTEX_PROJECT_ID);
+    }
+    /**
+     * Check Vertex AI authentication
+     */
+    static async checkVertexAuthentication(healthStatus) {
+        let hasValidAuth = false;
+        if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+            hasValidAuth = await this.checkGoogleApplicationCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            hasValidAuth = this.checkIndividualGoogleCredentials(healthStatus);
+        }
+        if (!hasValidAuth) {
+            healthStatus.configurationIssues.push("Google Cloud authentication not configured or credentials file missing");
+            healthStatus.recommendations.push("Set either GOOGLE_APPLICATION_CREDENTIALS (valid file path), GOOGLE_SERVICE_ACCOUNT_KEY (base64), or both GOOGLE_AUTH_CLIENT_EMAIL and GOOGLE_AUTH_PRIVATE_KEY");
+        }
+        return hasValidAuth;
+    }
+    /**
+     * Check Google Application Credentials file
+     */
+    static async checkGoogleApplicationCredentials(healthStatus) {
+        const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        if (!credentialsPath) {
+            healthStatus.warning =
+                "GOOGLE_APPLICATION_CREDENTIALS environment variable not set";
+            return false;
+        }
+        try {
+            const { promises: fs } = await import("fs");
+            await fs.access(credentialsPath);
+            const fileName = basename(credentialsPath);
+            const jsonFilePattern = /\.json(\.\w+)?$/;
+            if (!jsonFilePattern.test(fileName)) {
+                healthStatus.warning =
+                    "GOOGLE_APPLICATION_CREDENTIALS should point to a JSON file";
             }
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        catch {
+            healthStatus.warning = `GOOGLE_APPLICATION_CREDENTIALS file does not exist: ${credentialsPath}`;
+            return false;
+        }
+    }
+    /**
+     * Check individual Google credentials
+     */
+    static checkIndividualGoogleCredentials(healthStatus) {
+        const hasServiceAccountKey = !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY;
+        const hasIndividualCredentials = !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+            process.env.GOOGLE_AUTH_PRIVATE_KEY);
+        if (hasServiceAccountKey || hasIndividualCredentials) {
+            healthStatus.hasApiKey = true;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check AWS Bedrock configuration
+     */
+    static async checkBedrockConfig(healthStatus) {
+        logger.debug("Starting AWS Bedrock comprehensive health check");
+        this.checkAWSRegion(healthStatus);
+        this.checkAWSCredentials(healthStatus);
+        this.checkBedrockModels(healthStatus);
+        this.checkBedrockEndpoint(healthStatus);
+        if (healthStatus.configurationIssues.length === 0) {
+            healthStatus.hasApiKey = true;
+            logger.debug("AWS Bedrock configuration appears valid");
+        }
+    }
+    /**
+     * Check AWS region configuration
+     */
+    static checkAWSRegion(healthStatus) {
+        const awsRegion = process.env.AWS_REGION;
+        const validBedrockRegions = [
+            "us-east-1",
+            "us-west-2",
+            "ap-southeast-1",
+            "ap-northeast-1",
+            "eu-central-1",
+            "eu-west-1",
+            "ap-south-1",
+        ];
+        if (!awsRegion) {
+            healthStatus.configurationIssues.push("AWS_REGION not set");
+            healthStatus.recommendations.push(`Set AWS_REGION to a Bedrock-supported region: ${validBedrockRegions.join(", ")}`);
+        }
+        else if (!validBedrockRegions.includes(awsRegion)) {
+            healthStatus.configurationIssues.push(`AWS_REGION '${awsRegion}' may not support all Bedrock models`);
+            healthStatus.recommendations.push(`Consider using a primary Bedrock region: ${validBedrockRegions.slice(0, 3).join(", ")}`);
+        }
+    }
+    /**
+     * Check AWS credentials
+     */
+    static checkAWSCredentials(healthStatus) {
+        const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+        const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+        const awsProfile = process.env.AWS_PROFILE;
+        if (!awsAccessKeyId && !awsProfile) {
+            healthStatus.configurationIssues.push("No AWS credentials found");
+            healthStatus.recommendations.push("Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or configure AWS_PROFILE");
+        }
+        else if (awsAccessKeyId && !awsSecretAccessKey) {
+            healthStatus.configurationIssues.push("AWS_ACCESS_KEY_ID set but AWS_SECRET_ACCESS_KEY missing");
+            healthStatus.recommendations.push("Set AWS_SECRET_ACCESS_KEY to match your AWS_ACCESS_KEY_ID");
+        }
+    }
+    /**
+     * Check Bedrock models
+     */
+    static checkBedrockModels(healthStatus) {
+        const bedrockModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+        const supportedModels = [
+            "anthropic.claude-3-sonnet-20240229-v1:0",
+            "anthropic.claude-3-haiku-20240307-v1:0",
+            "anthropic.claude-3-opus-20240229-v1:0",
+            "anthropic.claude-v2:1",
+            "amazon.titan-text-express-v1",
+        ];
+        if (!bedrockModel) {
+            healthStatus.recommendations.push("Set BEDROCK_MODEL or BEDROCK_MODEL_ID for faster startup (e.g., anthropic.claude-3-sonnet-20240229-v1:0)");
+        }
+        else if (!supportedModels.includes(bedrockModel)) {
+            healthStatus.recommendations.push(`Consider using a popular Bedrock model: ${supportedModels.slice(0, 3).join(", ")}`);
+        }
+    }
+    /**
+     * Check Bedrock endpoint
+     */
+    static checkBedrockEndpoint(healthStatus) {
+        const bedrockEndpoint = process.env.BEDROCK_ENDPOINT_URL;
+        if (bedrockEndpoint && !bedrockEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("BEDROCK_ENDPOINT_URL should use HTTPS");
+            healthStatus.recommendations.push("Update BEDROCK_ENDPOINT_URL to use HTTPS protocol");
+        }
+    }
+    /**
+     * Check Azure OpenAI configuration
+     */
+    static async checkAzureConfig(healthStatus) {
+        const azureEndpoint = process.env.AZURE_OPENAI_ENDPOINT;
+        if (azureEndpoint && !azureEndpoint.startsWith("https://")) {
+            healthStatus.configurationIssues.push("Invalid AZURE_OPENAI_ENDPOINT format");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_ENDPOINT to a valid URL (e.g., https://your-resource.openai.azure.com/)");
+        }
+        if (!process.env.AZURE_OPENAI_DEPLOYMENT_NAME) {
+            healthStatus.configurationIssues.push("AZURE_OPENAI_DEPLOYMENT_NAME not set");
+            healthStatus.recommendations.push("Set AZURE_OPENAI_DEPLOYMENT_NAME to your deployment name");
+        }
+    }
+    /**
+     * Check Ollama configuration
+     */
+    static async checkOllamaConfig(healthStatus) {
+        const ollamaBase = process.env.OLLAMA_API_BASE || "http://localhost:11434";
+        if (!ollamaBase.startsWith("http")) {
+            healthStatus.configurationIssues.push("Invalid OLLAMA_API_BASE format");
+            healthStatus.recommendations.push("Set OLLAMA_API_BASE to a valid URL (e.g., http://localhost:11434)");
         }
     }
     /**

package/dist/utils/providerUtils.js

@@ -107,7 +107,7 @@ async function isProviderAvailable(providerName) {
             }
             return false;
         }
-        catch (error) {
+        catch {
             return false;
         }
     }
@@ -116,7 +116,7 @@ async function isProviderAvailable(providerName) {
         await provider.generate({ prompt: "test", maxTokens: 1 });
         return true;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }

package/dist/utils/timeout.js

@@ -214,14 +214,17 @@ export class TimeoutManager {
     generateOperationId(operation) {
         return `${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
     }
-    createTimeoutPromise(timeoutMs, operationId) {
+    createTimeoutPromise(timeoutMs, _operationId) {
         let timer;
         const promise = new Promise((_, reject) => {
             timer = setTimeout(() => {
                 reject(new TimeoutError(`Operation timeout after ${timeoutMs}ms`, timeoutMs));
             }, timeoutMs);
         });
-        return { promise, timer: timer };
+        if (!timer) {
+            throw new Error("Failed to create timeout timer");
+        }
+        return { promise, timer };
     }
     registerTimeout(operationId, timer, controller, cleanup) {
         this.activeTimeouts.set(operationId, { timer, controller, cleanup });
@@ -291,7 +294,9 @@ export async function* withStreamingTimeout(generator, timeout, provider) {
         }
     }
     finally {
-        clearTimeout(timeoutId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.29.2",
+  "version": "7.30.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",

package/dist/context/ContextManager.d.ts

@@ -1,28 +0,0 @@
-import type { TextGenerationOptions, TextGenerationResult } from "../core/types.js";
-import type { ContextManagerConfig } from "./types.js";
-type InternalGenerator = (options: TextGenerationOptions) => Promise<TextGenerationResult>;
-/**
- * Manages conversation context, automatically summarizing it when it
- * exceeds a specified word count limit.
- */
-export declare class ContextManager {
-    private static readonly SUMMARIZATION_FAILED_WARNING;
-    private static readonly SUMMARIZATION_EMPTY_WARNING;
-    private history;
-    private wordCount;
-    private readonly internalGenerator;
-    private readonly config;
-    constructor(generatorFunction: InternalGenerator, config: ContextManagerConfig, initialContext?: string);
-    addTurn(role: "user" | "assistant", message: string): Promise<void>;
-    /**
-     * Formats the history including the latest user turn for the prompt, without modifying the permanent history.
-     */
-    getContextForPrompt(role: "user", message: string): string;
-    getCurrentContext(): string;
-    private _summarize;
-    /**
-     * Truncates the history to a specific word count, preserving the most recent messages.
-     */
-    private _truncateHistory;
-}
-export {};

package/dist/context/ContextManager.js

@@ -1,113 +0,0 @@
-import { logger } from "../utils/logger.js";
-import { formatHistoryToString } from "./utils.js";
-/**
- * Manages conversation context, automatically summarizing it when it
- * exceeds a specified word count limit.
- */
-export class ContextManager {
-    static SUMMARIZATION_FAILED_WARNING = "[System Warning: Context summarization failed. Conversation history has been truncated.]";
-    static SUMMARIZATION_EMPTY_WARNING = "[System Warning: Context summarization failed to return valid content. Conversation history has been truncated.]";
-    history;
-    wordCount;
-    internalGenerator;
-    config;
-    constructor(generatorFunction, config, initialContext = "This is the start of the conversation.") {
-        this.internalGenerator = generatorFunction;
-        this.config = config;
-        const initialMessage = {
-            role: "system",
-            content: initialContext,
-        };
-        initialMessage.wordCount = this.config.estimateWordCount([initialMessage]);
-        this.history = [initialMessage];
-        this.wordCount = initialMessage.wordCount;
-    }
-    async addTurn(role, message) {
-        const newMessage = { role, content: message };
-        newMessage.wordCount = this.config.estimateWordCount([newMessage]);
-        this.history.push(newMessage);
-        this.wordCount += newMessage.wordCount;
-        logger.info(`[ContextManager] Current word count: ${this.wordCount} / ${this.config.highWaterMarkWords}`);
-        if (this.wordCount > this.config.highWaterMarkWords) {
-            await this._summarize();
-        }
-    }
-    /**
-     * Formats the history including the latest user turn for the prompt, without modifying the permanent history.
-     */
-    getContextForPrompt(role, message) {
-        const tempHistory = [...this.history, { role, content: message }];
-        return formatHistoryToString(tempHistory);
-    }
-    getCurrentContext() {
-        // Format the history into a single string for the provider prompt
-        return formatHistoryToString(this.history);
-    }
-    async _summarize() {
-        try {
-            const prompt = this.config.getSummarizationPrompt(this.history, this.config.lowWaterMarkWords);
-            // Construct options for the internal method, bypassing the main 'generate' entry point
-            const textOptions = {
-                prompt,
-                provider: this.config.summarizationProvider,
-                model: this.config.summarizationModel,
-                // Ensure summarization does not trigger more context management or tools
-                disableTools: true,
-            };
-            // Call the internal generation function directly to avoid recursion
-            const result = await this.internalGenerator(textOptions);
-            if (typeof result.content === "string" && result.content.length > 0) {
-                // Replace the history with a single system message containing the summary
-                const newHistory = [
-                    { role: "system", content: result.content },
-                ];
-                this.history = newHistory;
-                this.wordCount = this.config.estimateWordCount(this.history);
-                logger.info(`[ContextManager] Summarization complete. New history length: ${this.wordCount} words.`);
-            }
-            else {
-                logger.warn("[ContextManager] Summarization returned empty or non-string content; truncating history as a fallback.");
-                this._truncateHistory(this.config.lowWaterMarkWords);
-                this.history.unshift({
-                    role: "system",
-                    content: ContextManager.SUMMARIZATION_EMPTY_WARNING,
-                });
-                this.wordCount = this.config.estimateWordCount(this.history);
-            }
-            logger.debug(`[ContextManager] New history: ${JSON.stringify(this.history)}`);
-        }
-        catch (error) {
-            logger.error("Context summarization failed:", { error });
-            // Fallback strategy: truncate the history to the target word count.
-            this._truncateHistory(this.config.lowWaterMarkWords);
-            this.history.unshift({
-                role: "system",
-                content: ContextManager.SUMMARIZATION_FAILED_WARNING,
-            });
-            this.wordCount = this.config.estimateWordCount(this.history);
-        }
-    }
-    /**
-     * Truncates the history to a specific word count, preserving the most recent messages.
-     */
-    _truncateHistory(wordLimit) {
-        if (this.wordCount <= wordLimit) {
-            return;
-        }
-        let runningCount = 0;
-        let sliceIndex = this.history.length;
-        for (let i = this.history.length - 1; i >= 0; i--) {
-            let wordCount = this.history[i].wordCount;
-            if (wordCount === undefined) {
-                logger.warn(`[ContextManager] Word count cache missing for message at index ${i}. Recalculating.`);
-                wordCount = this.config.estimateWordCount([this.history[i]]);
-            }
-            runningCount += wordCount;
-            if (runningCount > wordLimit) {
-                sliceIndex = i + 1;
-                break;
-            }
-        }
-        this.history = this.history.slice(sliceIndex);
-    }
-}

package/dist/context/config.d.ts

@@ -1,5 +0,0 @@
-import type { ContextManagerConfig } from "./types.js";
-/**
- * Default configuration for the ContextManager.
- */
-export declare const defaultContextConfig: ContextManagerConfig;