@juspay/neurolink 9.10.0 → 9.11.0

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/adapters/video/videoAnalyzer.d.ts

@@ -8,16 +8,16 @@
  */
 import { AIProviderName } from "../../constants/enums.js";
 import type { CoreMessage } from "ai";
-export declare function analyzeVideoWithVertexAI(frames: CoreMessage, options?: {
+export declare function analyzeVideoWithVertexAI(messages: CoreMessage[], options?: {
     project?: string;
     location?: string;
     model?: string;
 }): Promise<string>;
-export declare function analyzeVideoWithGeminiAPI(frames: CoreMessage, options?: {
+export declare function analyzeVideoWithGeminiAPI(messages: CoreMessage[], options?: {
     apiKey?: string;
     model?: string;
 }): Promise<string>;
-export declare function analyzeVideo(frames: CoreMessage, options?: {
+export declare function analyzeVideo(messages: CoreMessage[], options?: {
     provider?: AIProviderName;
     project?: string;
     location?: string;

package/dist/lib/adapters/video/videoAnalyzer.js

@@ -9,23 +9,35 @@
 import { AIProviderName, ErrorSeverity, ErrorCategory, } from "../../constants/enums.js";
 import { logger } from "../../utils/logger.js";
 import { readFile } from "node:fs/promises";
-import { NeuroLinkError } from "../../utils/errorHandling.js";
+import { NeuroLinkError, ErrorFactory } from "../../utils/errorHandling.js";
 // ---------------------------------------------------------------------------
 // Shared config
 // ---------------------------------------------------------------------------
 const DEFAULT_MODEL = "gemini-2.0-flash";
 const DEFAULT_LOCATION = "us-central1";
+/**
+ * Extract content items from user messages
+ *
+ * @param messages - Array of CoreMessage objects
+ * @returns Flattened array of content items from user messages
+ */
+function extractUserContent(messages) {
+    const userMessages = messages.filter((msg) => msg.role === "user");
+    return userMessages.flatMap((msg) => Array.isArray(msg.content) ? msg.content : []);
+}
 /**
  * Convert CoreMessage content array to Gemini parts format
  *
- * @param contentArray - Array of content items from CoreMessage
+ * @param messages - Array of CoreMessage objects
  * @returns Array of parts in Gemini API format
  */
-function buildContentParts(frames) {
-    const contentArray = Array.isArray(frames.content) ? frames.content : [];
-    return contentArray.map((item) => {
-        if (item.type === "text" && item.text) {
-            return { text: item.text };
+function buildContentParts(messages) {
+    const allContent = extractUserContent(messages);
+    return allContent
+        .map((item) => {
+        if (item.type === "text") {
+            // Accept text parts regardless of whether text is empty
+            return { text: item.text || "" };
         }
         else if (item.type === "image" && item.image) {
             let base64Data;
@@ -38,7 +50,7 @@ function buildContentParts(frames) {
                 base64Data = item.image.replace(/^data:image\/[a-z]+;base64,/, "");
             }
             else {
-                throw new Error(`Invalid image data type: expected string, Buffer, or Uint8Array, got ${typeof item.image}`);
+                throw ErrorFactory.invalidConfiguration("image data type", `expected string, Buffer, or Uint8Array, got ${typeof item.image}`, { itemType: item.type, dataType: typeof item.image });
             }
             return {
                 inlineData: {
@@ -47,8 +59,14 @@ function buildContentParts(frames) {
                 },
             };
         }
-        throw new Error(`Invalid content type: ${item.type}`);
-    });
+        else if (item.type === "file") {
+            // Skip file parts - not supported in Gemini parts format
+            return null;
+        }
+        // Return null for unsupported types
+        return null;
+    })
+        .filter((part) => part !== null);
 }
 /**
  * Configuration for video frame analysis.
@@ -88,7 +106,7 @@ Ensure the final response is fully self-sufficient and does not reference extern
 // ---------------------------------------------------------------------------
 // Vertex AI
 // ---------------------------------------------------------------------------
-export async function analyzeVideoWithVertexAI(frames, options = {}) {
+export async function analyzeVideoWithVertexAI(messages, options = {}) {
     const startTime = Date.now();
     const { GoogleGenAI } = await import("@google/genai");
     // Get default config and merge with provided options
@@ -96,9 +114,9 @@ export async function analyzeVideoWithVertexAI(frames, options = {}) {
     const project = options.project ?? config.project;
     const location = options.location ?? config.location;
     const model = options.model || DEFAULT_MODEL;
-    // Extract content array from CoreMessage
-    const contentArray = Array.isArray(frames.content) ? frames.content : [];
-    const frameCount = contentArray.filter((item) => item.type === "image").length;
+    // Convert frames content to parts array for Gemini
+    const parts = buildContentParts(messages);
+    const frameCount = parts.filter((part) => "inlineData" in part && part.inlineData).length;
     logger.debug("[GeminiVideoAnalyzer] Analyzing video with Vertex AI", {
         project,
         location,
@@ -106,8 +124,6 @@ export async function analyzeVideoWithVertexAI(frames, options = {}) {
         frameCount,
     });
     const ai = new GoogleGenAI({ vertexai: true, project, location });
-    // Convert frames content to parts array for Gemini
-    const parts = buildContentParts(frames);
     const response = await ai.models.generateContent({
         model,
         config: buildConfig(),
@@ -129,7 +145,7 @@ export async function analyzeVideoWithVertexAI(frames, options = {}) {
 // ---------------------------------------------------------------------------
 // Gemini API (Google AI)
 // ---------------------------------------------------------------------------
-export async function analyzeVideoWithGeminiAPI(frames, options = {}) {
+export async function analyzeVideoWithGeminiAPI(messages, options = {}) {
     const startTime = Date.now();
     const { GoogleGenAI } = await import("@google/genai");
     const apiKey = options.apiKey || process.env.GOOGLE_AI_API_KEY;
@@ -137,16 +153,14 @@ export async function analyzeVideoWithGeminiAPI(frames, options = {}) {
     if (!apiKey) {
         throw new Error("GOOGLE_AI_API_KEY environment variable is required for Gemini API video analysis");
     }
-    // Extract content array from CoreMessage
-    const contentArray = Array.isArray(frames.content) ? frames.content : [];
-    const frameCount = contentArray.filter((item) => item.type === "image").length;
+    // Convert frames content to parts array for Gemini
+    const parts = buildContentParts(messages);
+    const frameCount = parts.filter((part) => "inlineData" in part && part.inlineData).length;
     logger.debug("[GeminiVideoAnalyzer] Analyzing video with Gemini API", {
         model,
         frameCount,
     });
     const ai = new GoogleGenAI({ apiKey });
-    // Convert frames content to parts array for Gemini
-    const parts = buildContentParts(frames);
     logger.debug("[GeminiVideoAnalyzer] Generating analysis with frames");
     const response = await ai.models.generateContent({
         model,
@@ -207,15 +221,15 @@ async function getVertexConfig() {
     }
     return { project, location };
 }
-export async function analyzeVideo(frames, options = {}) {
+export async function analyzeVideo(messages, options = {}) {
     const provider = options.provider || AIProviderName.AUTO;
     // Vertex — only when GOOGLE_VERTEX_PROJECT is explicitly set
     if (provider === AIProviderName.VERTEX || provider === AIProviderName.AUTO) {
-        return analyzeVideoWithVertexAI(frames, options);
+        return analyzeVideoWithVertexAI(messages, options);
     }
     // Gemini API — when GOOGLE_AI_API_KEY is set
     if (provider === AIProviderName.GOOGLE_AI && process.env.GOOGLE_AI_API_KEY) {
-        return analyzeVideoWithGeminiAPI(frames, options);
+        return analyzeVideoWithGeminiAPI(messages, options);
     }
     throw new Error("No valid provider configuration found. " +
         "Set GOOGLE_VERTEX_PROJECT for Vertex AI or GOOGLE_AI_API_KEY for Gemini API.");

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;
 /**