@juspay/neurolink 9.10.1 → 9.12.0

package/dist/core/modules/MessageBuilder.js

@@ -76,25 +76,44 @@ export class MessageBuilder {
             messages = await buildMessagesArray(options);
         }
         // Convert messages to Vercel AI SDK format
+        // Preserve providerOptions (e.g. Anthropic cache_control) through conversion
         return messages.map((msg) => {
+            const providerOptions = msg
+                .providerOptions;
             if (typeof msg.content === "string") {
                 return {
                     role: msg.role,
                     content: msg.content,
+                    ...(providerOptions && { providerOptions }),
                 };
             }
             else {
                 return {
                     role: msg.role,
                     content: msg.content.map((item) => {
+                        const itemProviderOptions = item
+                            .providerOptions;
                         if (item.type === "text") {
-                            return { type: "text", text: item.text || "" };
+                            return {
+                                type: "text",
+                                text: item.text || "",
+                                ...(itemProviderOptions && {
+                                    providerOptions: itemProviderOptions,
+                                }),
+                            };
                         }
                         else if (item.type === "image") {
-                            return { type: "image", image: item.image || "" };
+                            return {
+                                type: "image",
+                                image: item.image || "",
+                                ...(itemProviderOptions && {
+                                    providerOptions: itemProviderOptions,
+                                }),
+                            };
                         }
                         return item;
                     }),
+                    ...(providerOptions && { providerOptions }),
                 };
             }
         });
@@ -159,25 +178,44 @@ export class MessageBuilder {
             messages = await buildMessagesArray(options);
         }
         // Convert messages to Vercel AI SDK format
+        // Preserve providerOptions (e.g. Anthropic cache_control) through conversion
         return messages.map((msg) => {
+            const providerOptions = msg
+                .providerOptions;
             if (typeof msg.content === "string") {
                 return {
                     role: msg.role,
                     content: msg.content,
+                    ...(providerOptions && { providerOptions }),
                 };
             }
             else {
                 return {
                     role: msg.role,
                     content: msg.content.map((item) => {
+                        const itemProviderOptions = item
+                            .providerOptions;
                         if (item.type === "text") {
-                            return { type: "text", text: item.text || "" };
+                            return {
+                                type: "text",
+                                text: item.text || "",
+                                ...(itemProviderOptions && {
+                                    providerOptions: itemProviderOptions,
+                                }),
+                            };
                         }
                         else if (item.type === "image") {
-                            return { type: "image", image: item.image || "" };
+                            return {
+                                type: "image",
+                                image: item.image || "",
+                                ...(itemProviderOptions && {
+                                    providerOptions: itemProviderOptions,
+                                }),
+                            };
                         }
                         return item;
                     }),
+                    ...(providerOptions && { providerOptions }),
                 };
             }
         });

package/dist/core/modules/TelemetryHandler.js

@@ -17,6 +17,7 @@ import { nanoid } from "nanoid";
 import { logger } from "../../utils/logger.js";
 import { getPerformanceOptimizedProvider, recordProviderPerformanceFromMetrics, } from "../evaluationProviders.js";
 import { modelConfig } from "../modelConfiguration.js";
+import { TelemetryService } from "../../telemetry/telemetryService.js";
 /**
  * TelemetryHandler class - Handles analytics and telemetry for AI providers
  */
@@ -79,6 +80,8 @@ export class TelemetryHandler {
                 cost: actualCost,
                 success: true,
             });
+            // Wire TelemetryService metrics so OTEL counters/histograms are populated
+            TelemetryService.getInstance().recordAIRequest(this.providerName, this.modelName, usage?.totalTokens || 0, responseTime, actualCost > 0 ? actualCost : undefined);
             const optimizedProvider = getPerformanceOptimizedProvider("speed");
             logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
                 responseTime: `${responseTime}ms`,
@@ -147,7 +150,7 @@ export class TelemetryHandler {
             isEnabled: true,
             functionId,
             metadata,
-            recordInputs: false,
+            recordInputs: process.env.NEUROLINK_RECORD_INPUTS?.toLowerCase() === "true",
             recordOutputs: true,
         };
     }

package/dist/core/redisConversationMemoryManager.d.ts

@@ -48,7 +48,13 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
     /**
      * Get session by ID, reconstructing a SessionMemory from Redis storage.
      */
-    getSession(sessionId: string, userId?: string): Promise<SessionMemory | undefined>;
+    getSession(sessionId: string, userId?: string, requestId?: string): Promise<SessionMemory | undefined>;
+    /**
+     * Get raw session data without any filtering or transformation.
+     * Used by the memory retrieval tool and internal APIs that need
+     * access to full message data including unmodified tool outputs.
+     */
+    getSessionRaw(sessionId: string, userId?: string): Promise<RedisConversationObject | null>;
     /**
      * Get all sessions for a specific user
      */
@@ -90,9 +96,9 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
-     * Filters out tool_call and tool_result messages when summarization is enabled
+     * Applies sendToolPreview toggle and hydrates result.result for backward compat
      */
-    buildContextMessages(sessionId: string, userId?: string, enableSummarization?: boolean): Promise<ChatMessage[]>;
+    buildContextMessages(sessionId: string, userId?: string, enableSummarization?: boolean, requestId?: string): Promise<ChatMessage[]>;
     /**
      * Get session metadata for a specific user session (optimized for listing)
      * Fetches only essential metadata without heavy message arrays
@@ -131,6 +137,16 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * Create summary system message
      */
     createSummarySystemMessage(content: string, summarizesFrom?: string, summarizesTo?: string): ChatMessage;
+    /**
+     * Get the raw messages array for a session.
+     * Returns the full messages list without context filtering or summarization.
+     */
+    getSessionMessages(sessionId: string, userId?: string): Promise<ChatMessage[]>;
+    /**
+     * Replace the entire messages array for a session.
+     * The session must already exist in Redis.
+     */
+    setSessionMessages(sessionId: string, messages: ChatMessage[], userId?: string): Promise<void>;
     /**
      * Close Redis connection
      */

package/dist/core/redisConversationMemoryManager.js

@@ -4,6 +4,7 @@
  */
 import { randomUUID } from "crypto";
 import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
+import { generateToolOutputPreview } from "../context/toolOutputLimits.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
 import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
@@ -102,7 +103,7 @@ export class RedisConversationMemoryManager {
     /**
      * Get session by ID, reconstructing a SessionMemory from Redis storage.
      */
-    async getSession(sessionId, userId) {
+    async getSession(sessionId, userId, requestId) {
         await this.ensureInitialized();
         if (!this.redisClient) {
             return undefined;
@@ -114,6 +115,34 @@ export class RedisConversationMemoryManager {
             if (!conversation) {
                 return undefined;
             }
+            // Log session load metadata for observability
+            const blobSizeBytes = conversationData
+                ? Buffer.byteLength(conversationData, "utf8")
+                : 0;
+            const messageCount = conversation.messages.length;
+            const hasSummary = !!conversation.summarizedUpToMessageId;
+            const pointerIndex = hasSummary
+                ? conversation.messages.findIndex((msg) => msg.id === conversation.summarizedUpToMessageId)
+                : -1;
+            const recentMessageCount = hasSummary && pointerIndex !== -1
+                ? messageCount - pointerIndex - 1
+                : messageCount;
+            logger.info("[ConversationMemory] Session loaded", {
+                requestId,
+                sessionId,
+                blobSizeBytes,
+                messageCount,
+                hasSummary,
+                recentMessageCount,
+            });
+            if (blobSizeBytes > 512 * 1024) {
+                logger.warn("[ConversationMemory] Large session blob", {
+                    requestId,
+                    sessionId,
+                    blobSizeBytes,
+                    messageCount,
+                });
+            }
             return {
                 sessionId: conversation.sessionId,
                 userId: conversation.userId,
@@ -137,6 +166,30 @@ export class RedisConversationMemoryManager {
             return undefined;
         }
     }
+    /**
+     * Get raw session data without any filtering or transformation.
+     * Used by the memory retrieval tool and internal APIs that need
+     * access to full message data including unmodified tool outputs.
+     */
+    async getSessionRaw(sessionId, userId) {
+        try {
+            await this.ensureInitialized();
+            if (!this.redisClient) {
+                return null;
+            }
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            return deserializeConversation(conversationData || null);
+        }
+        catch (error) {
+            logger.error("[RedisConversationMemoryManager] Failed to get raw session", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
     /**
      * Get all sessions for a specific user
      */
@@ -377,7 +430,7 @@ export class RedisConversationMemoryManager {
                 if (!this.summarizationInProgress.has(summarizationKey)) {
                     setImmediate(async () => {
                         try {
-                            await this.checkAndSummarize(conversation, tokenThreshold, options.sessionId, options.userId);
+                            await this.checkAndSummarize(conversation, tokenThreshold, options.sessionId, options.userId, options.requestId);
                         }
                         catch (error) {
                             logger.error("Background summarization failed", {
@@ -396,6 +449,24 @@ export class RedisConversationMemoryManager {
             }
             const serializedData = serializeConversation(conversation);
             await this.redisClient.set(redisKey, serializedData);
+            // Log turn storage metadata for observability
+            const blobSizeBytes = Buffer.byteLength(serializedData, "utf8");
+            logger.info("[ConversationMemory] Turn stored", {
+                requestId: options.requestId,
+                sessionId: options.sessionId,
+                blobSizeBytes,
+                totalMessages: conversation.messages.length,
+                userMsgChars: options.userMessage.length,
+                assistantMsgChars: options.aiResponse.length,
+            });
+            if (blobSizeBytes > 512 * 1024) {
+                logger.warn("[ConversationMemory] Large session blob", {
+                    requestId: options.requestId,
+                    sessionId: options.sessionId,
+                    blobSizeBytes,
+                    messageCount: conversation.messages.length,
+                });
+            }
             if (this.redisConfig.ttl > 0) {
                 await this.redisClient.expire(redisKey, this.redisConfig.ttl);
             }
@@ -418,7 +489,7 @@ export class RedisConversationMemoryManager {
     /**
      * Check if summarization is needed based on token count
      */
-    async checkAndSummarize(conversation, threshold, sessionId, userId) {
+    async checkAndSummarize(conversation, threshold, sessionId, userId, requestId) {
         const normalizedUserId = userId || "randomUser";
         const summarizationKey = `${sessionId}:${normalizedUserId}`;
         if (this.summarizationInProgress.has(summarizationKey)) {
@@ -442,7 +513,7 @@ export class RedisConversationMemoryManager {
                 createdAt: new Date(conversation.createdAt).getTime(),
                 lastActivity: new Date(conversation.updatedAt).getTime(),
             };
-            const summarized = await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[RedisConversationMemoryManager]");
+            const summarized = await this.summarizationEngine.checkAndSummarize(session, threshold, this.config, "[RedisConversationMemoryManager]", requestId);
             conversation.lastTokenCount = session.lastTokenCount;
             conversation.lastCountedAt = session.lastCountedAt;
             if (summarized) {
@@ -471,9 +542,9 @@ export class RedisConversationMemoryManager {
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
-     * Filters out tool_call and tool_result messages when summarization is enabled
+     * Applies sendToolPreview toggle and hydrates result.result for backward compat
      */
-    async buildContextMessages(sessionId, userId, enableSummarization) {
+    async buildContextMessages(sessionId, userId, enableSummarization, requestId) {
         logger.info("[RedisConversationMemoryManager] Building context messages", {
             sessionId,
             userId,
@@ -497,14 +568,34 @@ export class RedisConversationMemoryManager {
             createdAt: new Date(conversation.createdAt).getTime(),
             lastActivity: new Date(conversation.updatedAt).getTime(),
         };
-        const contextMessages = buildContextFromPointer(session);
-        const isSummarizationEnabled = enableSummarization !== undefined
-            ? enableSummarization
-            : this.config.enableSummarization === true;
-        let finalMessages = contextMessages;
-        if (isSummarizationEnabled) {
-            finalMessages = contextMessages.filter((msg) => msg.role !== "tool_call" && msg.role !== "tool_result");
-        }
+        const contextMessages = buildContextFromPointer(session, requestId);
+        const sendToolPreview = this.config?.contextCompaction?.sendToolPreview === true;
+        // Map tool_result messages: apply preview toggle + hydrate result.result
+        const finalMessages = contextMessages.map((msg) => {
+            if (msg.role !== "tool_result") {
+                return msg;
+            }
+            // Toggle: swap content to preview if enabled AND a preview exists
+            const content = sendToolPreview && msg.metadata?.toolOutputPreview
+                ? msg.metadata.toolOutputPreview
+                : msg.content;
+            // Hydrate result.result from content for backward compatibility
+            // (result.result is no longer stored — inferred from content at read time)
+            let hydratedResult = msg.result;
+            if (msg.result && msg.result.result === undefined) {
+                let parsedResult = content;
+                try {
+                    parsedResult = JSON.parse(content);
+                }
+                catch {
+                    /* plain text — use as-is */
+                }
+                hydratedResult = { ...msg.result, result: parsedResult };
+            }
+            return { ...msg, content, result: hydratedResult };
+        });
+        // Tool messages now have real content and participate in context properly.
+        // The tool output pruner (Stage 1) handles bounding old tool outputs.
         logger.info("[RedisConversationMemoryManager] Retrieved context messages", {
             sessionId,
             userId,
@@ -756,6 +847,75 @@ User message: "${userMessage}"`;
             },
         };
     }
+    /**
+     * Get the raw messages array for a session.
+     * Returns the full messages list without context filtering or summarization.
+     */
+    async getSessionMessages(sessionId, userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            return [];
+        }
+        try {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            const conversation = deserializeConversation(conversationData || null);
+            return conversation?.messages ?? [];
+        }
+        catch (error) {
+            logger.error("[RedisConversationMemoryManager] Failed to get session messages", {
+                sessionId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Replace the entire messages array for a session.
+     * The session must already exist in Redis.
+     */
+    async setSessionMessages(sessionId, messages, userId) {
+        await this.ensureInitialized();
+        if (!this.redisClient) {
+            throw new ConversationMemoryError("Redis client not initialized", "STORAGE_ERROR", { sessionId });
+        }
+        try {
+            const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+            const conversationData = await this.redisClient.get(redisKey);
+            const conversation = deserializeConversation(conversationData || null);
+            if (!conversation) {
+                throw new ConversationMemoryError(`Session ${sessionId} not found`, "STORAGE_ERROR", { sessionId });
+            }
+            conversation.messages = messages;
+            conversation.updatedAt = new Date().toISOString();
+            // Reset summarization pointers — the old summary no longer applies
+            // to the replaced messages array
+            conversation.summarizedUpToMessageId = undefined;
+            conversation.summarizedMessage = undefined;
+            conversation.lastTokenCount = undefined;
+            conversation.lastCountedAt = undefined;
+            const serializedData = serializeConversation(conversation);
+            await this.redisClient.set(redisKey, serializedData);
+            if (this.redisConfig.ttl > 0) {
+                await this.redisClient.expire(redisKey, this.redisConfig.ttl);
+            }
+            logger.debug("[RedisConversationMemoryManager] Session messages replaced", {
+                sessionId,
+                userId,
+                messageCount: messages.length,
+            });
+        }
+        catch (error) {
+            if (error instanceof ConversationMemoryError) {
+                throw error;
+            }
+            throw new ConversationMemoryError(`Failed to set session messages for session ${sessionId}`, "STORAGE_ERROR", {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     /**
      * Close Redis connection
      */
@@ -966,52 +1126,87 @@ User message: "${userMessage}"`;
             toolCallsCount: pendingData.toolCalls.length,
             toolResultsCount: pendingData.toolResults.length,
         });
-        // Create a mapping from toolCallId to toolName for matching tool results
-        const toolCallMap = new Map();
-        // Create separate messages for tool calls and build the mapping
-        for (const toolCall of pendingData.toolCalls) {
-            const toolCallId = String(toolCall.toolCallId);
-            const toolName = String(toolCall.toolName);
-            // Store in mapping for tool results
-            toolCallMap.set(toolCallId, toolName);
-            const toolCallMessage = {
-                id: randomUUID(),
-                timestamp: toolCall.timestamp?.toISOString() || this.generateTimestamp(),
-                role: "tool_call",
-                content: "", // Can be empty for tool calls
-                tool: toolName,
-                args: (toolCall.args ||
-                    toolCall.arguments ||
-                    toolCall.parameters ||
-                    {}),
-            };
-            conversation.messages.push(toolCallMessage);
-        }
-        // Create separate messages for tool results using the mapping
-        for (const toolResult of pendingData.toolResults) {
-            const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
-            const toolName = toolCallMap.get(toolCallId) || "unknown";
-            const toolResultMessage = {
-                id: randomUUID(),
-                timestamp: toolResult.timestamp?.toISOString() || this.generateTimestamp(),
-                role: "tool_result",
-                content: "", // Can be empty for tool results
-                tool: toolName, // Now correctly extracted from tool call mapping
-                result: {
+        try {
+            // Create a mapping from toolCallId to toolName for matching tool results
+            const toolCallMap = new Map();
+            // Create separate messages for tool calls and build the mapping
+            for (const toolCall of pendingData.toolCalls) {
+                const toolCallId = toolCall.toolCallId ?? "";
+                const toolName = toolCall.toolName ?? "";
+                // Store in mapping for tool results
+                toolCallMap.set(toolCallId, toolName);
+                const toolCallMessage = {
+                    id: randomUUID(),
+                    timestamp: toolCall.timestamp?.toISOString() || this.generateTimestamp(),
+                    role: "tool_call",
+                    content: "", // Can be empty for tool calls
+                    tool: toolName,
+                    args: (toolCall.args ||
+                        toolCall.arguments ||
+                        toolCall.parameters ||
+                        {}),
+                };
+                conversation.messages.push(toolCallMessage);
+            }
+            // Create separate messages for tool results using the mapping
+            for (const toolResult of pendingData.toolResults) {
+                const toolCallId = String(toolResult.toolCallId || toolResult.id || "unknown");
+                const toolName = toolCallMap.get(toolCallId) || "unknown";
+                // Serialize the tool result to string for content field
+                let serializedResult;
+                if (typeof toolResult.result === "string") {
+                    serializedResult = toolResult.result;
+                }
+                else if (toolResult.result === undefined ||
+                    toolResult.result === null) {
+                    serializedResult = String(toolResult.result ?? "null");
+                }
+                else {
+                    try {
+                        serializedResult = JSON.stringify(toolResult.result, null, 2);
+                    }
+                    catch (serializeError) {
+                        serializedResult = `[Serialization failed: ${serializeError instanceof Error ? serializeError.message : String(serializeError)}]`;
+                    }
+                }
+                // Generate preview (uses existing config fields that were previously unused)
+                const { preview, truncated, originalSize } = generateToolOutputPreview(serializedResult, {
+                    maxBytes: this.config?.contextCompaction?.maxToolOutputBytes,
+                    maxLines: this.config?.contextCompaction?.maxToolOutputLines,
+                });
+                // Build metadata — only store preview when truncation occurred (no duplication)
+                const metadata = {
+                    truncated,
+                    ...(truncated && { toolOutputPreview: preview }),
+                    ...(truncated && { originalSize }),
+                };
+                // Build result — success/error metadata only, NOT the output data
+                const result = {
                     success: !toolResult.error,
-                    result: toolResult.result,
+                    // result.result intentionally NOT stored — inferred from content at read time
                     error: toolResult.error ? String(toolResult.error) : undefined,
-                },
-            };
-            conversation.messages.push(toolResultMessage);
+                };
+                const toolResultMessage = {
+                    id: randomUUID(),
+                    timestamp: toolResult.timestamp?.toISOString() || this.generateTimestamp(),
+                    role: "tool_result",
+                    content: serializedResult, // Full output (was "")
+                    tool: toolName,
+                    result,
+                    metadata,
+                };
+                conversation.messages.push(toolResultMessage);
+            }
+            logger.debug("[RedisConversationMemoryManager] Successfully flushed pending tool data", {
+                sessionId,
+                userId,
+                toolMessagesAdded: pendingData.toolCalls.length + pendingData.toolResults.length,
+                totalMessages: conversation.messages.length,
+            });
+        }
+        finally {
+            // Always clean up pending data, even on failure, to prevent infinite retry loops
+            this.pendingToolExecutions.delete(pendingKey);
         }
-        // Remove the pending data now that it's been flushed
-        this.pendingToolExecutions.delete(pendingKey);
-        logger.debug("[RedisConversationMemoryManager] Successfully flushed pending tool data", {
-            sessionId,
-            userId,
-            toolMessagesAdded: pendingData.toolCalls.length + pendingData.toolResults.length,
-            totalMessages: conversation.messages.length,
-        });
     }
 }

package/dist/index.d.ts

@@ -42,6 +42,8 @@ export type { DynamicModelConfig, ModelRegistry } from "./types/modelTypes.js";
 export { getAvailableProviders, getBestProvider, isValidProvider, } from "./utils/providerUtils.js";
 export { calculateCost, hasPricing } from "./utils/pricing.js";
 export { isAbortError } from "./utils/errorHandling.js";
+export { TTSProcessor } from "./utils/ttsProcessor.js";
+export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };
 export type { MCPServerInfo } from "./types/mcpTypes.js";

package/dist/index.js

@@ -49,6 +49,9 @@ export { getAvailableProviders, getBestProvider, isValidProvider, } from "./util
 export { calculateCost, hasPricing } from "./utils/pricing.js";
 // Error utilities
 export { isAbortError } from "./utils/errorHandling.js";
+// TTS utilities
+export { TTSProcessor } from "./utils/ttsProcessor.js";
+export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 // Main NeuroLink wrapper class and diagnostic types
 import { NeuroLink } from "./neurolink.js";
 export { NeuroLink };

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

@@ -221,11 +221,11 @@ export declare const directAgentTools: {
     }, "strip", z.ZodTypeAny, {
         content: string;
         path: string;
-        mode: "create" | "append" | "overwrite";
+        mode: "create" | "overwrite" | "append";
     }, {
         content: string;
         path: string;
-        mode?: "create" | "append" | "overwrite" | undefined;
+        mode?: "create" | "overwrite" | "append" | undefined;
     }>, {
         success: boolean;
         error: string;
@@ -236,7 +236,7 @@ export declare const directAgentTools: {
     } | {
         success: boolean;
         path: string;
-        mode: "create" | "append" | "overwrite";
+        mode: "create" | "overwrite" | "append";
         size: number;
         written: number;
         error?: undefined;
@@ -251,7 +251,7 @@ export declare const directAgentTools: {
         execute: (args: {
             content: string;
             path: string;
-            mode: "create" | "append" | "overwrite";
+            mode: "create" | "overwrite" | "append";
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
             error: string;
@@ -262,7 +262,7 @@ export declare const directAgentTools: {
         } | {
             success: boolean;
             path: string;
-            mode: "create" | "append" | "overwrite";
+            mode: "create" | "overwrite" | "append";
             size: number;
             written: number;
             error?: undefined;
@@ -282,8 +282,8 @@ export declare const directAgentTools: {
         maxRows: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
-        filePath: string;
         maxRows: number;
+        filePath: string;
         column: string;
     }, {
         operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
@@ -309,8 +309,8 @@ export declare const directAgentTools: {
     }> & {
         execute: (args: {
             operation: "count_by_column" | "sum_by_column" | "average_by_column" | "min_max_by_column" | "describe";
-            filePath: string;
             maxRows: number;
+            filePath: string;
             column: string;
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;

package/dist/lib/constants/contextWindows.d.ts

@@ -25,9 +25,12 @@ export declare const MODEL_CONTEXT_WINDOWS: Record<string, Record<string, number
  * Resolve context window size for a provider/model combination.
  *
  * Priority:
- *  1. Exact model match under provider
- *  2. Provider's _default
- *  3. Global DEFAULT_CONTEXT_WINDOW
+ *  0. Dynamic model registry (DynamicModelProvider) — resolves cross-provider
+ *     models (e.g. Claude on Vertex) that the static table cannot handle
+ *  1. Exact model match under provider in static registry
+ *  2. Prefix match under provider in static registry
+ *  3. Provider's _default in static registry
+ *  4. Global DEFAULT_CONTEXT_WINDOW
  */
 export declare function getContextWindowSize(provider: string, model?: string): number;
 /**