@juspay/neurolink 7.0.0 → 7.2.0

package/dist/cli/utils/completeSetup.js

@@ -7,6 +7,7 @@
 import { runInteractiveSetup, testProviderConnectivity, displaySetupSummary, } from "./interactiveSetup.js";
 import { updateEnvFile, displayEnvUpdateSummary } from "./envManager.js";
 import chalk from "chalk";
+import { logger } from "../../lib/utils/logger.js";
 /**
  * Run the complete interactive setup process
  */
@@ -14,20 +15,20 @@ export async function runCompleteSetup(quiet = false) {
     try {
         // Step 1: Run interactive setup wizard
         if (!quiet) {
-            console.log(chalk.blue("🚀 Starting NeuroLink Configuration Setup...\n"));
+            logger.always(chalk.blue("🚀 Starting NeuroLink Configuration Setup...\n"));
         }
         const setupResult = await runInteractiveSetup(quiet);
         // If no providers selected, exit early
         if (setupResult.selectedProviders.length === 0) {
             if (!quiet) {
-                console.log(chalk.yellow("⚠️  No providers selected. Setup cancelled."));
+                logger.always(chalk.yellow("⚠️  No providers selected. Setup cancelled."));
             }
             return setupResult;
         }
         // Step 2: Update environment file with credentials
         if (Object.keys(setupResult.credentials).length > 0) {
             if (!quiet) {
-                console.log(chalk.blue("\n💾 Updating environment configuration...\n"));
+                logger.always(chalk.blue("\n💾 Updating environment configuration...\n"));
             }
             try {
                 const envResult = updateEnvFile(setupResult.credentials, ".env", true);
@@ -42,14 +43,14 @@ export async function runCompleteSetup(quiet = false) {
             }
             catch (error) {
                 if (!quiet) {
-                    console.error(chalk.red(`❌ Failed to update environment file: ${error instanceof Error ? error.message : String(error)}`));
+                    logger.error(chalk.red(`❌ Failed to update environment file: ${error instanceof Error ? error.message : String(error)}`));
                 }
                 throw error;
             }
         }
         // Step 3: Test provider connectivity
         if (!quiet) {
-            console.log(chalk.blue("\n🧪 Testing configured providers...\n"));
+            logger.always(chalk.blue("\n🧪 Testing configured providers...\n"));
         }
         setupResult.testResults = await testProviderConnectivity(setupResult.selectedProviders, quiet);
         // Step 4: Display summary
@@ -58,8 +59,8 @@ export async function runCompleteSetup(quiet = false) {
     }
     catch (error) {
         if (!quiet) {
-            console.error(chalk.red(`❌ Setup failed: ${error instanceof Error ? error.message : String(error)}`));
-            console.log(chalk.yellow("💡 You can retry setup with: neurolink config setup"));
+            logger.error(chalk.red(`❌ Setup failed: ${error instanceof Error ? error.message : String(error)}`));
+            logger.always(chalk.yellow("💡 You can retry setup with: neurolink config setup"));
         }
         throw error;
     }
@@ -75,7 +76,7 @@ export async function configSetup(quiet = false) {
  */
 export async function configInit(quiet = false) {
     if (!quiet) {
-        console.log(chalk.gray("📝 config init is an alias for config setup\n"));
+        logger.always(chalk.gray("📝 config init is an alias for config setup\n"));
     }
     await runCompleteSetup(quiet);
 }

package/dist/cli/utils/envManager.js

@@ -5,6 +5,7 @@
  */
 import fs from "fs";
 import chalk from "chalk";
+import { logger } from "../../lib/utils/logger.js";
 /**
  * Create a timestamped backup of the existing .env file
  */
@@ -158,23 +159,23 @@ export function displayEnvUpdateSummary(result, quiet = false) {
         return;
     }
     if (result.backup.existed && result.backup.backupPath) {
-        console.log(chalk.gray(`💾 Created backup: ${result.backup.backupPath}`));
+        logger.always(chalk.gray(`💾 Created backup: ${result.backup.backupPath}`));
     }
     if (result.added.length > 0) {
-        console.log(chalk.green(`➕ Added ${result.added.length} new variables: ${result.added.join(", ")}`));
+        logger.always(chalk.green(`➕ Added ${result.added.length} new variables: ${result.added.join(", ")}`));
     }
     if (result.updated.length > 0) {
-        console.log(chalk.yellow(`🔄 Updated ${result.updated.length} existing variables: ${result.updated.join(", ")}`));
+        logger.always(chalk.yellow(`🔄 Updated ${result.updated.length} existing variables: ${result.updated.join(", ")}`));
     }
     if (result.unchanged.length > 0) {
-        console.log(chalk.gray(`✓ ${result.unchanged.length} variables unchanged: ${result.unchanged.join(", ")}`));
+        logger.always(chalk.gray(`✓ ${result.unchanged.length} variables unchanged: ${result.unchanged.join(", ")}`));
     }
     const totalChanges = result.added.length + result.updated.length;
     if (totalChanges > 0) {
-        console.log(chalk.blue(`📝 Environment file updated with ${totalChanges} changes`));
+        logger.always(chalk.blue(`📝 Environment file updated with ${totalChanges} changes`));
     }
     else {
-        console.log(chalk.gray("📝 No changes needed to environment file"));
+        logger.always(chalk.gray("📝 No changes needed to environment file"));
     }
 }
 /**

package/dist/cli/utils/interactiveSetup.js

@@ -8,6 +8,7 @@ import { AIProviderName } from "../../lib/core/types.js";
 import { NeuroLink } from "../../lib/neurolink.js";
 import chalk from "chalk";
 import ora from "ora";
+import { logger } from "../../lib/utils/logger.js";
 export const PROVIDER_CONFIGS = [
     {
         id: AIProviderName.OPENAI,
@@ -145,8 +146,8 @@ export async function runInteractiveSetup(quiet = false) {
         testResults: [],
     };
     if (!quiet) {
-        console.log(chalk.blue("\n🎉 Welcome to NeuroLink Interactive Setup!"));
-        console.log(chalk.gray("This wizard will help you configure AI providers for NeuroLink.\n"));
+        logger.always(chalk.blue("\n🎉 Welcome to NeuroLink Interactive Setup!"));
+        logger.always(chalk.gray("This wizard will help you configure AI providers for NeuroLink.\n"));
     }
     // Step 1: Provider Selection
     const providerChoices = PROVIDER_CONFIGS.map((config) => ({
@@ -171,7 +172,7 @@ export async function runInteractiveSetup(quiet = false) {
     result.selectedProviders = selectedProviders;
     // Step 2: Credential Collection
     if (!quiet) {
-        console.log(chalk.blue("\n🔑 Collecting credentials for selected providers...\n"));
+        logger.always(chalk.blue("\n🔑 Collecting credentials for selected providers...\n"));
     }
     for (const providerId of selectedProviders) {
         const config = PROVIDER_CONFIGS.find((c) => c.id === providerId);
@@ -179,7 +180,7 @@ export async function runInteractiveSetup(quiet = false) {
             continue;
         }
         if (!quiet) {
-            console.log(chalk.yellow(`\n📋 Configuring ${config.name}:`));
+            logger.always(chalk.yellow(`\n📋 Configuring ${config.name}:`));
         }
         for (const envVar of config.envVars) {
             const currentValue = process.env[envVar.key];
@@ -235,7 +236,7 @@ export async function testProviderConnectivity(providers, quiet = false) {
     const sdk = new NeuroLink();
     const results = [];
     if (!quiet) {
-        console.log(chalk.blue("\n🧪 Testing provider connectivity...\n"));
+        logger.always(chalk.blue("\n🧪 Testing provider connectivity...\n"));
     }
     const spinner = quiet ? null : ora().start();
     for (const provider of providers) {
@@ -252,7 +253,7 @@ export async function testProviderConnectivity(providers, quiet = false) {
                 spinner.start(); // Restart for next provider
             }
             else if (!quiet) {
-                console.log(`${provider}: ${chalk.green("✅ Working")} (${duration}ms)`);
+                logger.always(`${provider}: ${chalk.green("✅ Working")} (${duration}ms)`);
             }
         }
         catch (error) {
@@ -263,7 +264,7 @@ export async function testProviderConnectivity(providers, quiet = false) {
                 spinner.start(); // Restart for next provider
             }
             else if (!quiet) {
-                console.error(`${provider}: ${chalk.red("❌ Failed")} - ${errorMessage.split("\n")[0]}`);
+                logger.error(`${provider}: ${chalk.red("❌ Failed")} - ${errorMessage.split("\n")[0]}`);
             }
         }
     }
@@ -281,22 +282,22 @@ export function displaySetupSummary(result, quiet = false) {
     }
     const working = result.testResults.filter((r) => r.status === "working").length;
     const total = result.testResults.length;
-    console.log(chalk.blue("\n📊 Setup Summary:"));
-    console.log(chalk.blue("================"));
-    console.log(`Selected providers: ${result.selectedProviders.length}`);
-    console.log(`Working providers: ${working}/${total}`);
+    logger.always(chalk.blue("\n📊 Setup Summary:"));
+    logger.always(chalk.blue("================"));
+    logger.always(`Selected providers: ${result.selectedProviders.length}`);
+    logger.always(`Working providers: ${working}/${total}`);
     if (result.envFileBackup) {
-        console.log(chalk.gray(`Environment backup: ${result.envFileBackup}`));
+        logger.always(chalk.gray(`Environment backup: ${result.envFileBackup}`));
     }
     if (working > 0) {
-        console.log(chalk.green("\n✅ Setup completed successfully!"));
-        console.log(chalk.yellow("💡 You can now use NeuroLink with your configured providers."));
-        console.log(chalk.gray('   Try: neurolink generate "Hello, AI!"'));
+        logger.always(chalk.green("\n✅ Setup completed successfully!"));
+        logger.always(chalk.yellow("💡 You can now use NeuroLink with your configured providers."));
+        logger.always(chalk.gray('   Try: neurolink generate "Hello, AI!"'));
     }
     else {
-        console.log(chalk.red("\n❌ No providers are working."));
-        console.log(chalk.yellow("💡 Please check your credentials and try again."));
-        console.log(chalk.gray("   Run: neurolink config setup"));
+        logger.always(chalk.red("\n❌ No providers are working."));
+        logger.always(chalk.yellow("💡 Please check your credentials and try again."));
+        logger.always(chalk.gray("   Run: neurolink config setup"));
     }
-    console.log(chalk.blue("\n📚 Documentation: https://github.com/juspay/neurolink#setup"));
+    logger.always(chalk.blue("\n📚 Documentation: https://github.com/juspay/neurolink#setup"));
 }

package/dist/core/analytics.js

@@ -50,52 +50,39 @@ export function createAnalytics(provider, model, result, responseTime, context)
  * Extract token usage from various AI result formats
  */
 function extractTokenUsage(result) {
-    // Handle different response formats
+    // Use properly typed usage object from BaseProvider or direct AI SDK
     if (result.usage &&
         typeof result.usage === "object" &&
         result.usage !== null) {
         const usage = result.usage;
-        // Standard format
-        if (typeof usage.promptTokens === "number" &&
-            typeof usage.completionTokens === "number") {
-            return {
-                input: usage.promptTokens || 0,
-                output: usage.completionTokens || 0,
-                total: typeof usage.totalTokens === "number"
-                    ? usage.totalTokens
-                    : usage.promptTokens + usage.completionTokens,
-            };
+        // Try BaseProvider normalized format first (inputTokens/outputTokens)
+        if (typeof usage.inputTokens === "number" ||
+            typeof usage.outputTokens === "number") {
+            const input = typeof usage.inputTokens === "number" ? usage.inputTokens : 0;
+            const output = typeof usage.outputTokens === "number" ? usage.outputTokens : 0;
+            const total = typeof usage.totalTokens === "number"
+                ? usage.totalTokens
+                : input + output;
+            return { input, output, total };
         }
-        // Alternative formats
-        if (typeof usage.input_tokens === "number" &&
-            typeof usage.output_tokens === "number") {
-            return {
-                input: usage.input_tokens || 0,
-                output: usage.output_tokens || 0,
-                total: typeof usage.total_tokens === "number"
-                    ? usage.total_tokens
-                    : usage.input_tokens + usage.output_tokens,
-            };
+        // Try OpenAI/Mistral format (promptTokens/completionTokens)
+        if (typeof usage.promptTokens === "number" ||
+            typeof usage.completionTokens === "number") {
+            const input = typeof usage.promptTokens === "number" ? usage.promptTokens : 0;
+            const output = typeof usage.completionTokens === "number" ? usage.completionTokens : 0;
+            const total = typeof usage.totalTokens === "number"
+                ? usage.totalTokens
+                : input + output;
+            return { input, output, total };
         }
-        // Generic tokens field
-        if (typeof usage.tokens === "number") {
-            return {
-                input: 0,
-                output: 0,
-                total: usage.tokens,
-            };
+        // Handle total-only case
+        if (typeof usage.totalTokens === "number") {
+            return { input: 0, output: 0, total: usage.totalTokens };
         }
     }
-    // Fallback: estimate from text length
-    const textLength = (typeof result.text === "string" ? result.text.length : 0) ||
-        (typeof result.content === "string" ? result.content.length : 0) ||
-        0;
-    const estimatedTokens = Math.ceil(textLength / 4); // ~4 chars per token
-    return {
-        input: 0,
-        output: estimatedTokens,
-        total: estimatedTokens,
-    };
+    // Fallback for edge cases
+    logger.debug("Token extraction failed: unknown usage format", { result });
+    return { input: 0, output: 0, total: 0 };
 }
 /**
  * Estimate cost based on provider, model, and token usage

package/dist/core/baseProvider.d.ts

@@ -447,5 +447,13 @@ export declare abstract class BaseProvider implements AIProvider {
      * Get timeout value in milliseconds
      */
     getTimeout(options: TextGenerationOptions | StreamOptions): number;
+    /**
+     * Utility method to chunk large prompts into smaller pieces
+     * @param prompt The prompt to chunk
+     * @param maxChunkSize Maximum size per chunk (default: 900,000 characters)
+     * @param overlap Overlap between chunks to maintain context (default: 100 characters)
+     * @returns Array of prompt chunks
+     */
+    static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
 }
 export {};

package/dist/core/baseProvider.js

@@ -1,4 +1,5 @@
 import { logger } from "../utils/logger.js";
+import { SYSTEM_LIMITS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
 /**
  * Validates if a result contains a valid toolsObject structure
@@ -49,80 +50,96 @@ export class BaseProvider {
      */
     async stream(optionsOrPrompt, analysisSchema) {
         const options = this.normalizeStreamOptions(optionsOrPrompt);
-        // If tools are not disabled AND provider supports tools, use generate() and create synthetic stream
-        if (!options.disableTools && this.supportsTools()) {
-            try {
-                // Convert stream options to text generation options
-                const textOptions = {
-                    prompt: options.input?.text || "",
-                    systemPrompt: options.systemPrompt,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    disableTools: false,
-                    maxSteps: options.maxSteps || 5,
-                    provider: options.provider,
-                    model: options.model,
-                };
-                const result = await this.generate(textOptions, analysisSchema);
-                // Create a synthetic stream from the generate result that simulates progressive delivery
-                return {
-                    stream: (async function* () {
-                        if (result?.content) {
-                            // Split content into words for more natural streaming
-                            const words = result.content.split(/(\s+)/); // Keep whitespace
-                            let buffer = "";
-                            for (let i = 0; i < words.length; i++) {
-                                buffer += words[i];
-                                // Yield chunks of roughly 5-10 words or at punctuation
-                                const shouldYield = i === words.length - 1 || // Last word
-                                    buffer.length > 50 || // Buffer getting long
-                                    /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
-                                if (shouldYield && buffer.trim()) {
+        // CRITICAL FIX: Always prefer real streaming over fake streaming
+        // Try real streaming first, use fake streaming only as fallback
+        try {
+            const realStreamResult = await this.executeStream(options, analysisSchema);
+            // If real streaming succeeds, return it (with tools support via Vercel AI SDK)
+            return realStreamResult;
+        }
+        catch (realStreamError) {
+            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, realStreamError);
+            // Fallback to fake streaming only if real streaming fails AND tools are enabled
+            if (!options.disableTools && this.supportsTools()) {
+                try {
+                    // Convert stream options to text generation options
+                    const textOptions = {
+                        prompt: options.input?.text || "",
+                        systemPrompt: options.systemPrompt,
+                        temperature: options.temperature,
+                        maxTokens: options.maxTokens,
+                        disableTools: false,
+                        maxSteps: options.maxSteps || 5,
+                        provider: options.provider,
+                        model: options.model,
+                        // 🔧 FIX: Include analytics and evaluation options from stream options
+                        enableAnalytics: options.enableAnalytics,
+                        enableEvaluation: options.enableEvaluation,
+                        evaluationDomain: options.evaluationDomain,
+                        toolUsageContext: options.toolUsageContext,
+                        context: options.context,
+                    };
+                    const result = await this.generate(textOptions, analysisSchema);
+                    // Create a synthetic stream from the generate result that simulates progressive delivery
+                    return {
+                        stream: (async function* () {
+                            if (result?.content) {
+                                // Split content into words for more natural streaming
+                                const words = result.content.split(/(\s+)/); // Keep whitespace
+                                let buffer = "";
+                                for (let i = 0; i < words.length; i++) {
+                                    buffer += words[i];
+                                    // Yield chunks of roughly 5-10 words or at punctuation
+                                    const shouldYield = i === words.length - 1 || // Last word
+                                        buffer.length > 50 || // Buffer getting long
+                                        /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
+                                    if (shouldYield && buffer.trim()) {
+                                        yield { content: buffer };
+                                        buffer = "";
+                                        // Small delay to simulate streaming (1-10ms)
+                                        await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
+                                    }
+                                }
+                                // Yield any remaining content
+                                if (buffer.trim()) {
                                     yield { content: buffer };
-                                    buffer = "";
-                                    // Small delay to simulate streaming (1-10ms)
-                                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
                                 }
                             }
-                            // Yield any remaining content
-                            if (buffer.trim()) {
-                                yield { content: buffer };
-                            }
-                        }
-                    })(),
-                    usage: result?.usage,
-                    provider: result?.provider,
-                    model: result?.model,
-                    toolCalls: result?.toolCalls?.map((call) => ({
-                        toolName: call.toolName,
-                        parameters: call.args,
-                        id: call.toolCallId,
-                    })),
-                    toolResults: result?.toolResults
-                        ? result.toolResults.map((tr) => ({
-                            toolName: tr.toolName || "unknown",
-                            status: (tr.status === "error"
-                                ? "failure"
-                                : "success"),
-                            result: tr.result,
-                            error: tr.error,
-                        }))
-                        : undefined,
-                };
+                        })(),
+                        usage: result?.usage,
+                        provider: result?.provider,
+                        model: result?.model,
+                        toolCalls: result?.toolCalls?.map((call) => ({
+                            toolName: call.toolName,
+                            parameters: call.args,
+                            id: call.toolCallId,
+                        })),
+                        toolResults: result?.toolResults
+                            ? result.toolResults.map((tr) => ({
+                                toolName: tr.toolName || "unknown",
+                                status: (tr.status === "error"
+                                    ? "failure"
+                                    : "success"),
+                                result: tr.result,
+                                error: tr.error,
+                            }))
+                            : undefined,
+                        // 🔧 FIX: Include analytics and evaluation from generate result
+                        analytics: result?.analytics,
+                        evaluation: result?.evaluation,
+                    };
+                }
+                catch (error) {
+                    logger.error(`Fake streaming fallback failed for ${this.providerName}:`, error);
+                    throw this.handleProviderError(error);
+                }
             }
-            catch (error) {
-                logger.error(`Stream with tools failed for ${this.providerName}:`, error);
-                throw this.handleProviderError(error);
+            else {
+                // If real streaming failed and no tools are enabled, re-throw the original error
+                logger.error(`Real streaming failed for ${this.providerName}:`, realStreamError);
+                throw this.handleProviderError(realStreamError);
             }
         }
-        // Traditional streaming without tools
-        try {
-            return await this.executeStream(options, analysisSchema);
-        }
-        catch (error) {
-            logger.error(`Stream failed for ${this.providerName}:`, error);
-            throw this.handleProviderError(error);
-        }
     }
     /**
      * Text generation method - implements AIProvider interface
@@ -150,6 +167,31 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            // Extract tool names from tool calls for tracking
+            // AI SDK puts tool calls in steps array for multi-step generation
+            const toolsUsed = [];
+            // First check direct tool calls (fallback)
+            if (result.toolCalls && result.toolCalls.length > 0) {
+                toolsUsed.push(...result.toolCalls.map((tc) => {
+                    return (tc.toolName ||
+                        tc.name ||
+                        "unknown");
+                }));
+            }
+            // Then check steps for tool calls (primary source for multi-step)
+            if (result.steps &&
+                Array.isArray(result.steps)) {
+                for (const step of result.steps ||
+                    []) {
+                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                        toolsUsed.push(...step.toolCalls.map((tc) => {
+                            return tc.toolName || tc.name || "unknown";
+                        }));
+                    }
+                }
+            }
+            // Remove duplicates
+            const uniqueToolsUsed = [...new Set(toolsUsed)];
             // Format the result with tool executions included
             const enhancedResult = {
                 content: result.text,
@@ -174,6 +216,7 @@ export class BaseProvider {
                     }))
                     : [],
                 toolResults: result.toolResults,
+                toolsUsed: uniqueToolsUsed,
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -348,9 +391,43 @@ export class BaseProvider {
         return evaluation;
     }
     validateOptions(options) {
+        // 🔧 EDGE CASE: Basic prompt validation
         if (!options.prompt || options.prompt.trim().length === 0) {
             throw new Error("Prompt is required and cannot be empty");
         }
+        // 🔧 EDGE CASE: Handle very large prompts (>1M characters)
+        if (options.prompt.length > SYSTEM_LIMITS.MAX_PROMPT_LENGTH) {
+            throw new Error(`Prompt too large: ${options.prompt.length} characters (max: ${SYSTEM_LIMITS.MAX_PROMPT_LENGTH}). Consider breaking into smaller chunks. Use BaseProvider.chunkPrompt(prompt, maxSize, overlap) static method for chunking.`);
+        }
+        // 🔧 EDGE CASE: Validate token limits
+        if (options.maxTokens && options.maxTokens > 200000) {
+            throw new Error(`Max tokens too high: ${options.maxTokens} (recommended max: 200,000). This may cause timeouts or API errors.`);
+        }
+        if (options.maxTokens && options.maxTokens < 1) {
+            throw new Error("Max tokens must be at least 1");
+        }
+        // 🔧 EDGE CASE: Validate temperature range
+        if (options.temperature !== undefined) {
+            if (options.temperature < 0 || options.temperature > 2) {
+                throw new Error(`Temperature must be between 0 and 2, got: ${options.temperature}`);
+            }
+        }
+        // 🔧 EDGE CASE: Validate timeout values
+        if (options.timeout !== undefined) {
+            const timeoutMs = typeof options.timeout === "string"
+                ? parseInt(options.timeout, 10)
+                : options.timeout;
+            if (isNaN(timeoutMs) || timeoutMs < 1000) {
+                throw new Error(`Timeout must be at least 1000ms (1 second), got: ${options.timeout}`);
+            }
+            if (timeoutMs > SYSTEM_LIMITS.LONG_TIMEOUT_WARNING) {
+                logger.warn(`⚠️ Very long timeout: ${timeoutMs}ms. This may cause the CLI to hang.`);
+            }
+        }
+        // 🔧 EDGE CASE: Validate maxSteps for tool execution
+        if (options.maxSteps !== undefined && options.maxSteps > 20) {
+            throw new Error(`Max steps too high: ${options.maxSteps} (recommended max: 20). This may cause long execution times.`);
+        }
     }
     getProviderInfo() {
         return {
@@ -382,4 +459,36 @@ export class BaseProvider {
         }
         return this.defaultTimeout;
     }
+    /**
+     * Utility method to chunk large prompts into smaller pieces
+     * @param prompt The prompt to chunk
+     * @param maxChunkSize Maximum size per chunk (default: 900,000 characters)
+     * @param overlap Overlap between chunks to maintain context (default: 100 characters)
+     * @returns Array of prompt chunks
+     */
+    static chunkPrompt(prompt, maxChunkSize = 900000, overlap = 100) {
+        if (prompt.length <= maxChunkSize) {
+            return [prompt];
+        }
+        const chunks = [];
+        let start = 0;
+        while (start < prompt.length) {
+            const end = Math.min(start + maxChunkSize, prompt.length);
+            chunks.push(prompt.slice(start, end));
+            // Break if we've reached the end
+            if (end >= prompt.length) {
+                break;
+            }
+            // Move start forward, accounting for overlap
+            const nextStart = end - overlap;
+            // Ensure we make progress (avoid infinite loops)
+            if (nextStart <= start) {
+                start = end;
+            }
+            else {
+                start = Math.max(nextStart, 0);
+            }
+        }
+        return chunks;
+    }
 }

package/dist/core/constants.d.ts

@@ -36,6 +36,17 @@ export declare const CLI_LIMITS: {
         default: number;
     };
 };
+export declare const SYSTEM_LIMITS: {
+    MAX_PROMPT_LENGTH: number;
+    HIGH_MEMORY_THRESHOLD: number;
+    LONG_TIMEOUT_WARNING: number;
+    DEFAULT_CONCURRENCY_LIMIT: number;
+    MAX_CONCURRENCY_LIMIT: number;
+    DEFAULT_RETRY_ATTEMPTS: number;
+    DEFAULT_INITIAL_DELAY: number;
+    DEFAULT_MAX_DELAY: number;
+    DEFAULT_BACKOFF_MULTIPLIER: number;
+};
 export declare const ENV_DEFAULTS: {
     maxTokens: number;
     temperature: number;

package/dist/core/constants.js

@@ -40,6 +40,23 @@ export const CLI_LIMITS = {
         default: DEFAULT_TEMPERATURE,
     },
 };
+// Performance and System Limits
+export const SYSTEM_LIMITS = {
+    // Prompt size limits (baseProvider.ts magic number fix)
+    MAX_PROMPT_LENGTH: 1000000, // 1M characters - prevents memory issues
+    // Memory monitoring thresholds (performance.ts)
+    HIGH_MEMORY_THRESHOLD: 100, // MB - when to warn about memory usage
+    // Timeout warnings (baseProvider.ts)
+    LONG_TIMEOUT_WARNING: 300000, // 5 minutes - when to warn about long timeouts
+    // Concurrency control (neurolink.ts provider testing)
+    DEFAULT_CONCURRENCY_LIMIT: 3, // Max parallel provider tests
+    MAX_CONCURRENCY_LIMIT: 5, // Upper bound for concurrency
+    // Retry system defaults (retryHandler.ts)
+    DEFAULT_RETRY_ATTEMPTS: 3,
+    DEFAULT_INITIAL_DELAY: 1000, // 1 second
+    DEFAULT_MAX_DELAY: 30000, // 30 seconds
+    DEFAULT_BACKOFF_MULTIPLIER: 2,
+};
 // Environment Variable Support (for future use)
 export const ENV_DEFAULTS = {
     maxTokens: process.env.NEUROLINK_DEFAULT_MAX_TOKENS