@juspay/neurolink 9.25.2 → 9.26.0

package/dist/context/prompts/summarizationPrompt.js

@@ -1,10 +1,10 @@
 /**
  * Summarization Prompt Builder
  *
- * Builds prompts for summarizing conversation context into a 9-section structure.
+ * Builds prompts for summarizing conversation context into a 10-section structure.
  * Supports both initial summarization and incremental merging with existing summaries.
  */
-const NINE_SECTIONS = [
+const SUMMARY_SECTIONS = [
     "Primary Request and Intent",
     "Key Technical Concepts",
     "Files and Code Sections",
@@ -14,6 +14,7 @@ const NINE_SECTIONS = [
     "Current Work",
     "Next Step",
     "Required Files",
+    "Constraints and Established Rules",
 ];
 function buildFileContextSection(filesRead, filesModified) {
     const hasFiles = (filesRead && filesRead.length > 0) ||
@@ -38,7 +39,7 @@ function buildFileContextSection(filesRead, filesModified) {
 }
 function buildInitialPrompt(options) {
     const fileContext = buildFileContextSection(options.filesRead, options.filesModified);
-    return `You are a context summarization assistant. Your task is to analyze the conversation and create a structured summary following a 9-section format.
+    return `You are a context summarization assistant. Your task is to analyze the conversation and create a structured summary following a 10-section format.
 
 Create a summary with the following sections:
 
@@ -67,7 +68,12 @@ What is being actively worked on right now?
 What is the immediate next action to take?
 
 ### 9. Required Files
-What files will need to be accessed or modified to continue?${fileContext}
+What files will need to be accessed or modified to continue?
+
+### 10. Constraints and Established Rules
+What user-imposed constraints, behavioral directives, coding standards, agreed-upon decisions, or established rules must persist across the conversation? Include any "always do X", "never do Y", naming conventions, architectural patterns, or preferences the user has stated.${fileContext}
+
+IMPORTANT: Section 10 (Constraints and Established Rules) must ALWAYS be preserved in full. User constraints and established agreements are never "no longer relevant" — they remain in effect for the entire session unless the user explicitly revokes them.
 
 Analyze the conversation thoroughly and fill in each section with relevant information. If a section is not applicable, write "N/A" for that section.`;
 }
@@ -80,18 +86,19 @@ Existing Summary:
 ${options.previousSummary}
 ---
 
-Update sections with new information while preserving important context from the existing summary. Maintain the same 9-section structure.
+Update sections with new information while preserving important context from the existing summary. Maintain the same 10-section structure.
 
 Instructions:
 1. Review the existing summary above
 2. Analyze the new conversation content
 3. MERGE the new information into the appropriate sections
 4. Update sections with relevant new information
-5. Remove information that is no longer relevant
+5. Remove information that is no longer relevant EXCEPT for Section 10 (Constraints and Established Rules) — user constraints and established agreements must ALWAYS be preserved unless the user explicitly revoked them
 6. Keep the summary concise but comprehensive
-7. Maintain the 9-section format${fileContext}
+7. Maintain the 10-section format
+8. Always carry forward ALL entries from Section 10 of the existing summary, adding any new constraints found in the new content${fileContext}
 
-Output the updated summary following the same 9-section structure.`;
+Output the updated summary following the same 10-section structure.`;
 }
 /**
  * Builds a summarization prompt based on the provided options.
@@ -107,4 +114,4 @@ export function buildSummarizationPrompt(options) {
     }
     return buildInitialPrompt(options);
 }
-export { NINE_SECTIONS };
+export { SUMMARY_SECTIONS };

package/dist/context/stages/structuredSummarizer.d.ts

@@ -1,10 +1,10 @@
 /**
  * Stage 3: Structured LLM Summarization
  *
- * Uses the structured 9-section prompt to summarize older messages
+ * Uses the structured 10-section prompt to summarize older messages
  * while preserving recent ones.
  */
-import type { ChatMessage } from "../../types/conversation.js";
 import type { SummarizeConfig, SummarizeResult } from "../../types/contextTypes.js";
+import type { ChatMessage } from "../../types/conversation.js";
 export type { SummarizeConfig, SummarizeResult, } from "../../types/contextTypes.js";
 export declare function summarizeMessages(messages: ChatMessage[], config?: SummarizeConfig): Promise<SummarizeResult>;

package/dist/context/stages/structuredSummarizer.js

@@ -1,19 +1,59 @@
 /**
  * Stage 3: Structured LLM Summarization
  *
- * Uses the structured 9-section prompt to summarize older messages
+ * Uses the structured 10-section prompt to summarize older messages
  * while preserving recent ones.
  */
-import { generateSummary } from "../../utils/conversationMemory.js";
 import { randomUUID } from "crypto";
+import { generateSummary } from "../../utils/conversationMemory.js";
+import { estimateTokens } from "../../utils/tokenEstimation.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Find the split index using token counting — walk backward from the end,
+ * accumulating token counts until we've reserved `targetRecentTokens` worth
+ * of recent content. Everything before the split index gets summarized.
+ */
+function findSplitIndexByTokens(messages, targetRecentTokens, provider) {
+    let recentTokens = 0;
+    let splitIndex = messages.length;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const content = typeof messages[i].content === "string"
+            ? messages[i].content
+            : JSON.stringify(messages[i].content);
+        const msgTokens = estimateTokens(content, provider);
+        if (recentTokens + msgTokens > targetRecentTokens) {
+            splitIndex = i + 1;
+            break;
+        }
+        recentTokens += msgTokens;
+    }
+    // Ensure at least one message is summarized
+    return Math.max(1, splitIndex);
+}
 export async function summarizeMessages(messages, config) {
     const keepRecentRatio = config?.keepRecentRatio ?? 0.3;
     if (messages.length <= 4) {
         return { summarized: false, messages };
     }
-    // Keep the most recent messages unsummarized
-    const keepCount = Math.max(4, Math.ceil(messages.length * keepRecentRatio));
-    const splitIndex = messages.length - keepCount;
+    // Determine split point: prefer token-based when a target budget is available,
+    // fall back to message-count-based split for backward compatibility.
+    let splitIndex;
+    if (config?.targetTokens && config.targetTokens > 0) {
+        // Keep `keepRecentRatio` fraction of the target budget as recent context
+        const targetRecentTokens = Math.floor(config.targetTokens * keepRecentRatio);
+        // NOTE: config.provider is the summarization provider, not the generation
+        // provider. Ideally we'd use the generation/budget provider for accurate
+        // token estimation, but SummarizeConfig doesn't carry a separate
+        // budgetProvider field. This is a known design limitation.
+        splitIndex = findSplitIndexByTokens(messages, targetRecentTokens, config.provider);
+    }
+    else {
+        // Legacy: message-count-based split
+        const keepCount = Math.max(4, Math.ceil(messages.length * keepRecentRatio));
+        splitIndex = messages.length - keepCount;
+    }
+    // Clamp so at least the last message is always preserved (never summarize everything)
+    splitIndex = Math.min(splitIndex, messages.length - 1);
     if (splitIndex <= 0) {
         return { summarized: false, messages };
     }
@@ -21,29 +61,39 @@ export async function summarizeMessages(messages, config) {
     const recentMessages = messages.slice(splitIndex);
     // Find previous summary if exists
     const previousSummary = messagesToSummarize.find((m) => m.metadata?.isSummary)?.content;
-    // Use memory config for summarization if available
-    if (config?.memoryConfig) {
-        const summaryText = await generateSummary(messagesToSummarize, config.memoryConfig, "[ContextCompactor]", previousSummary);
-        if (!summaryText) {
-            return { summarized: false, messages };
-        }
-        const summaryMessage = {
-            id: `summary-${randomUUID()}`,
-            role: "user",
-            content: `[Previous conversation summary]:\n\n${summaryText}`,
-            timestamp: new Date().toISOString(),
-            metadata: {
-                isSummary: true,
-                summarizesFrom: messagesToSummarize[0]?.id,
-                summarizesTo: messagesToSummarize[messagesToSummarize.length - 1]?.id,
-            },
-        };
-        return {
-            summarized: true,
-            messages: [summaryMessage, ...recentMessages],
-            summaryText,
-        };
-    }
-    // Without memory config, we can't call LLM
-    return { summarized: false, messages };
+    // Build effective memory config: use provided memoryConfig, or construct from provider/model
+    const effectiveMemoryConfig = config?.memoryConfig ? { ...config.memoryConfig } : {};
+    // Fill in summarization provider/model from compactor config if not already set
+    if (!effectiveMemoryConfig.summarizationProvider && config?.provider) {
+        effectiveMemoryConfig.summarizationProvider = config.provider;
+    }
+    if (!effectiveMemoryConfig.summarizationModel && config?.model) {
+        effectiveMemoryConfig.summarizationModel = config.model;
+    }
+    // Only skip if there's genuinely no provider available
+    if (!effectiveMemoryConfig.summarizationProvider &&
+        !effectiveMemoryConfig.summarizationModel) {
+        logger.debug("[ContextCompactor] Stage 3 skipped: no summarization provider or model available");
+        return { summarized: false, messages };
+    }
+    const summaryText = await generateSummary(messagesToSummarize, effectiveMemoryConfig, "[ContextCompactor]", previousSummary);
+    if (!summaryText) {
+        return { summarized: false, messages };
+    }
+    const summaryMessage = {
+        id: `summary-${randomUUID()}`,
+        role: "user",
+        content: `[Previous conversation summary]:\n\n${summaryText}`,
+        timestamp: new Date().toISOString(),
+        metadata: {
+            isSummary: true,
+            summarizesFrom: messagesToSummarize[0]?.id,
+            summarizesTo: messagesToSummarize[messagesToSummarize.length - 1]?.id,
+        },
+    };
+    return {
+        summarized: true,
+        messages: [summaryMessage, ...recentMessages],
+        summaryText,
+    };
 }

package/dist/lib/adapters/providerImageAdapter.d.ts

@@ -14,34 +14,10 @@ export declare class MultimodalLogger {
  */
 export declare class ProviderImageAdapter {
     /**
-     * Main adapter method - routes to provider-specific formatting
+     * Validate image count against provider limits.
+     * Warns at 80% threshold, throws error if limit exceeded.
      */
-    static adaptForProvider(text: string, images: Array<Buffer | string>, provider: string, model: string): Promise<unknown>;
-    /**
-     * Format content for OpenAI (GPT-4o format)
-     */
-    private static formatForOpenAI;
-    /**
-     * Format content for Google AI (Gemini format)
-     */
-    private static formatForGoogleAI;
-    /**
-     * Format content for Anthropic (Claude format)
-     */
-    private static formatForAnthropic;
-    /**
-     * Format content for Vertex AI (model-specific routing)
-     */
-    private static formatForVertex;
-    /**
-     * Validate image count against provider limits
-     * Warns at 80% threshold, throws error if limit exceeded
-     */
-    private static validateImageCount;
-    /**
-     * Validate that provider and model support vision
-     */
-    private static validateVisionSupport;
+    static validateImageCount(imageCount: number, provider: string, model?: string): void;
     /**
      * Convert simple images array to advanced content format
      * @param text - Text content to include

package/dist/lib/adapters/providerImageAdapter.js

@@ -2,8 +2,8 @@
  * Provider Image Adapter - Smart routing for multimodal content
  * Handles provider-specific image formatting and vision capability validation
  */
-import { logger } from "../utils/logger.js";
 import { ImageProcessor } from "../utils/imageProcessor.js";
+import { logger } from "../utils/logger.js";
 /**
  * Simplified logger for essential error reporting only
  */
@@ -436,184 +436,15 @@ const VISION_CAPABILITIES = {
  * Provider Image Adapter - Smart routing and formatting
  */
 export class ProviderImageAdapter {
+    // NOTE: The legacy `adaptForProvider` method and its private helpers
+    // (formatForOpenAI, formatForGoogleAI, formatForAnthropic, formatForVertex,
+    // validateVisionSupport) were removed as dead code. The production image
+    // pipeline uses `convertSimpleImagesToProviderFormat` in messageBuilder.ts
+    // with Vercel AI SDK's native ImagePart format. Image count limits are
+    // enforced via the public `validateImageCount` method below.
     /**
-     * Main adapter method - routes to provider-specific formatting
-     */
-    static async adaptForProvider(text, images, provider, model) {
-        try {
-            // Validate provider supports vision
-            this.validateVisionSupport(provider, model);
-            let adaptedPayload;
-            // Process images based on provider requirements
-            switch (provider.toLowerCase()) {
-                case "openai":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "azure":
-                case "azure-openai":
-                    // Azure uses same format as OpenAI but validate with azure provider name
-                    this.validateImageCount(images.length, "azure");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "google-ai":
-                case "google":
-                    adaptedPayload = this.formatForGoogleAI(text, images);
-                    break;
-                case "anthropic":
-                    adaptedPayload = this.formatForAnthropic(text, images);
-                    break;
-                case "vertex":
-                    adaptedPayload = this.formatForVertex(text, images, model);
-                    break;
-                case "ollama":
-                    // Ollama uses same format as OpenAI but validate with ollama provider name
-                    this.validateImageCount(images.length, "ollama");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "huggingface":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "sagemaker":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "litellm":
-                    // LiteLLM uses same format as OpenAI but validate with litellm provider name
-                    this.validateImageCount(images.length, "litellm");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "mistral":
-                    // Mistral uses same format as OpenAI but validate with mistral provider name
-                    this.validateImageCount(images.length, "mistral");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "bedrock":
-                    // Bedrock uses same format as Anthropic but validate with bedrock provider name
-                    this.validateImageCount(images.length, "bedrock");
-                    adaptedPayload = this.formatForAnthropic(text, images, true);
-                    break;
-                case "openrouter":
-                    // OpenRouter routes to underlying providers, use OpenAI format
-                    this.validateImageCount(images.length, "openrouter");
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                default:
-                    throw new Error(`Vision not supported for provider: ${provider}`);
-            }
-            return adaptedPayload;
-        }
-        catch (error) {
-            MultimodalLogger.logError("ADAPTATION", error, {
-                provider,
-                model,
-                imageCount: images.length,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Format content for OpenAI (GPT-4o format)
-     */
-    static formatForOpenAI(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "openai");
-        }
-        const content = [{ type: "text", text }];
-        images.forEach((image, index) => {
-            try {
-                const imageUrl = ImageProcessor.processImageForOpenAI(image);
-                content.push({
-                    type: "image_url",
-                    image_url: { url: imageUrl },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "openai",
-                });
-                throw error;
-            }
-        });
-        return { messages: [{ role: "user", content }] };
-    }
-    /**
-     * Format content for Google AI (Gemini format)
-     */
-    static formatForGoogleAI(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "google-ai");
-        }
-        const parts = [{ text }];
-        images.forEach((image, index) => {
-            try {
-                const { mimeType, data } = ImageProcessor.processImageForGoogle(image);
-                parts.push({
-                    inlineData: { mimeType, data },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "google-ai",
-                });
-                throw error;
-            }
-        });
-        return { contents: [{ parts }] };
-    }
-    /**
-     * Format content for Anthropic (Claude format)
-     */
-    static formatForAnthropic(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "anthropic");
-        }
-        const content = [{ type: "text", text }];
-        images.forEach((image, index) => {
-            try {
-                const { mediaType, data } = ImageProcessor.processImageForAnthropic(image);
-                content.push({
-                    type: "image",
-                    source: {
-                        type: "base64",
-                        media_type: mediaType,
-                        data,
-                    },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "anthropic",
-                });
-                throw error;
-            }
-        });
-        return { messages: [{ role: "user", content }] };
-    }
-    /**
-     * Format content for Vertex AI (model-specific routing)
-     */
-    static formatForVertex(text, images, model) {
-        // Validate image count with model-specific limits before processing
-        this.validateImageCount(images.length, "vertex", model);
-        // Route based on model type, skip validation in delegated methods
-        if (model.includes("gemini")) {
-            return this.formatForGoogleAI(text, images, true);
-        }
-        else if (model.includes("claude")) {
-            return this.formatForAnthropic(text, images, true);
-        }
-        else {
-            return this.formatForGoogleAI(text, images, true);
-        }
-    }
-    /**
-     * Validate image count against provider limits
-     * Warns at 80% threshold, throws error if limit exceeded
+     * Validate image count against provider limits.
+     * Warns at 80% threshold, throws error if limit exceeded.
      */
     static validateImageCount(imageCount, provider, model) {
         const normalizedProvider = provider.toLowerCase();
@@ -659,27 +490,6 @@ export class ProviderImageAdapter {
                 `Maximum allowed: ${limit}. Please reduce the number of images.`);
         }
     }
-    /**
-     * Validate that provider and model support vision
-     */
-    static validateVisionSupport(provider, model) {
-        const normalizedProvider = normalizeVisionProvider(provider);
-        const supportedModels = VISION_CAPABILITIES[normalizedProvider];
-        if (!supportedModels) {
-            throw new Error(`Provider ${provider} does not support vision processing. ` +
-                `Supported providers: ${Object.keys(VISION_CAPABILITIES).join(", ")}`);
-        }
-        const isSupported = supportedModels.some((supportedModel) => model.toLowerCase().includes(supportedModel.toLowerCase()));
-        // Proxy providers route to arbitrary underlying models — skip the allowlist
-        // check for unknown models and let the underlying provider error if needed.
-        if (!isSupported && PROXY_PROVIDERS.has(normalizedProvider)) {
-            return;
-        }
-        if (!isSupported) {
-            throw new Error(`Provider ${provider} with model ${model} does not support vision processing. ` +
-                `Supported models for ${provider}: ${supportedModels.join(", ")}`);
-        }
-    }
     /**
      * Convert simple images array to advanced content format
      * @param text - Text content to include

package/dist/lib/agent/directTools.d.ts

@@ -464,6 +464,36 @@ export declare const directAgentTools: {
         }>;
     };
 };
+/**
+ * Bash command execution tool - exported separately for opt-in use.
+ *
+ * SECURITY: This tool is NOT included in directAgentTools by default.
+ * It must be explicitly enabled via:
+ *   - Environment variable: NEUROLINK_ENABLE_BASH_TOOL=true
+ *   - Config: toolConfig.enableBashTool = true
+ *
+ * Import this directly when you need bash execution capabilities:
+ *   import { bashTool } from '../agent/directTools.js';
+ */
+export declare const bashTool: import("ai").Tool<z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    command: string;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}>, unknown> & {
+    execute: (args: {
+        timeout: number;
+        command: string;
+        cwd?: string | undefined;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<unknown>;
+};
 /**
  * Type aliases for specific tool categories
  */
@@ -481,7 +511,9 @@ export type UtilityToolsMap = {
     calculateMath: typeof directAgentTools.calculateMath;
     listDirectory: typeof directAgentTools.listDirectory;
 };
-export type AllToolsMap = typeof directAgentTools;
+export type AllToolsMap = typeof directAgentTools & {
+    executeBashCommand?: typeof bashTool;
+};
 /**
  * Get a subset of tools for specific use cases with improved type safety
  */