@juspay/neurolink 7.14.2 → 7.14.3

package/dist/lib/mcp/toolRegistry.js

@@ -183,7 +183,29 @@ export class MCPToolRegistry extends MCPRegistry {
         }
     }
     /**
-     * Execute a tool with enhanced context
+     * Execute a tool with enhanced context and automatic result wrapping
+     *
+     * This method handles both raw return values and ToolResult objects:
+     * - Raw values (primitives, objects) are automatically wrapped in ToolResult format
+     * - Existing ToolResult objects are enhanced with execution metadata
+     * - All results include execution timing and context information
+     *
+     * @param toolName - Name of the tool to execute
+     * @param args - Parameters to pass to the tool execution function
+     * @param context - Execution context with session, user, and environment info
+     * @returns Promise resolving to ToolResult object with data, metadata, and usage info
+     * @throws Error if tool is not found or execution fails
+     *
+     * @example
+     * ```typescript
+     * // Tool that returns raw value
+     * const result = await toolRegistry.executeTool("calculator", { a: 5, b: 3, op: "add" });
+     * // result.data === 8, result.metadata contains execution info
+     *
+     * // Tool that returns ToolResult
+     * const result = await toolRegistry.executeTool("complexTool", { input: "test" });
+     * // result is enhanced ToolResult with additional metadata
+     * ```
      */
     async executeTool(toolName, args, context) {
         const startTime = Date.now();
@@ -221,22 +243,46 @@ export class MCPToolRegistry extends MCPRegistry {
             // Execute the actual tool
             registryLogger.debug(`Executing tool '${toolName}' with args:`, args);
             const toolResult = await toolImpl.execute(args, execContext);
-            // Add metadata to the tool result (don't double-wrap)
-            const toolResultObj = toolResult;
-            const result = {
-                ...toolResultObj,
-                usage: {
-                    ...(toolResultObj.usage || {}),
-                    executionTime: Date.now() - startTime,
-                },
-                metadata: {
-                    ...(toolResultObj.metadata || {}),
-                    toolName,
-                    serverId: tool.serverId,
-                    sessionId: execContext.sessionId,
-                    executionTime: Date.now() - startTime,
-                },
-            };
+            // Properly wrap raw results in ToolResult format
+            let result;
+            // Check if result is already a ToolResult object
+            if (toolResult &&
+                typeof toolResult === "object" &&
+                "success" in toolResult &&
+                typeof toolResult.success === "boolean") {
+                // Result is already a ToolResult, enhance with metadata
+                const toolResultObj = toolResult;
+                result = {
+                    ...toolResultObj,
+                    usage: {
+                        ...(toolResultObj.usage || {}),
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        ...(toolResultObj.metadata || {}),
+                        toolName,
+                        serverId: tool.serverId,
+                        sessionId: execContext.sessionId,
+                        executionTime: Date.now() - startTime,
+                    },
+                };
+            }
+            else {
+                // Result is a raw value, wrap it in ToolResult format
+                result = {
+                    success: true,
+                    data: toolResult,
+                    usage: {
+                        executionTime: Date.now() - startTime,
+                    },
+                    metadata: {
+                        toolName,
+                        serverId: tool.serverId,
+                        sessionId: execContext.sessionId,
+                        executionTime: Date.now() - startTime,
+                    },
+                };
+            }
             // Update statistics
             const duration = Date.now() - startTime;
             this.updateStats(toolName, duration);
@@ -406,6 +452,51 @@ export class MCPToolRegistry extends MCPRegistry {
      */
     registerTool(toolId, toolInfo, toolImpl) {
         registryLogger.debug(`Registering tool: ${toolId}`);
+        // Import validation functions synchronously - they are pure functions
+        let validateTool;
+        let isToolNameAvailable;
+        let suggestToolNames;
+        try {
+            // Try ES module import first
+            const toolRegistrationModule = require("../sdk/toolRegistration.js");
+            ({ validateTool, isToolNameAvailable, suggestToolNames } =
+                toolRegistrationModule);
+        }
+        catch (error) {
+            // Fallback: skip validation if import fails (graceful degradation)
+            registryLogger.warn("Tool validation module not available, skipping advanced validation", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Create minimal validation functions
+            validateTool = () => { }; // No-op
+            isToolNameAvailable = () => true; // Allow all names
+            suggestToolNames = () => ["alternative_tool"];
+        }
+        // Check if tool name is available (not reserved)
+        if (!isToolNameAvailable(toolId)) {
+            const suggestions = suggestToolNames(toolId);
+            registryLogger.error(`Tool registration failed for ${toolId}: Name not available`);
+            throw new Error(`Tool name '${toolId}' is not available (reserved or invalid format). ` +
+                `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+        }
+        // Create a simplified tool object for validation
+        const toolForValidation = {
+            description: toolInfo.description || "",
+            execute: async () => "",
+            parameters: undefined,
+            metadata: {
+                category: toolInfo.category,
+                serverId: toolInfo.serverId,
+            },
+        };
+        // Use comprehensive validation logic
+        try {
+            validateTool(toolId, toolForValidation);
+        }
+        catch (error) {
+            registryLogger.error(`Tool registration failed for ${toolId}:`, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
         this.tools.set(toolId, toolInfo);
         this.toolImpls.set(toolId, toolImpl);
         registryLogger.debug(`Successfully registered tool: ${toolId}`);

package/dist/lib/models/modelResolver.js

@@ -4,6 +4,7 @@
  * Part of Phase 4.1 - Models Command System
  */
 import { MODEL_REGISTRY, MODEL_ALIASES, USE_CASE_RECOMMENDATIONS, getAllModels, getModelById, getModelsByProvider, getAvailableProviders, calculateCost, formatModelForDisplay, } from "./modelRegistry.js";
+import { isNonNullObject } from "../utils/typeUtils.js";
 /**
  * Model resolver class with advanced search and recommendation functionality
  */
@@ -419,7 +420,7 @@ export function formatSearchResults(results) {
     return results.map((result) => {
         const modelDisplay = formatModelForDisplay(result.model);
         return {
-            ...(typeof modelDisplay === "object" && modelDisplay !== null
+            ...(isNonNullObject(modelDisplay)
                 ? modelDisplay
                 : {}),
             relevanceScore: result.score,

package/dist/lib/neurolink.d.ts

@@ -9,6 +9,8 @@ import type { TextGenerationOptions, TextGenerationResult } from "./core/types.j
 import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
+import type { JsonObject } from "./types/common.js";
+import type { BatchOperationResult } from "./types/typeAliases.js";
 import { EventEmitter } from "events";
 import type { ConversationMemoryConfig } from "./types/conversationTypes.js";
 import type { ExternalMCPServerInstance, ExternalMCPOperationResult, ExternalMCPToolInfo } from "./types/externalMcp.js";
@@ -207,7 +209,13 @@ export declare class NeuroLink {
      * Get all available tools including custom and in-memory ones
      * @returns Array of available tools with metadata
      */
-    getAllAvailableTools(): Promise<any[]>;
+    getAllAvailableTools(): Promise<{
+        name: string;
+        description: string;
+        server: string;
+        category?: string;
+        inputSchema?: import("./types/typeAliases.js").StandardRecord;
+    }[]>;
     /**
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics
@@ -435,9 +443,9 @@ export declare class NeuroLink {
      * @param options - Execution options
      * @returns Tool execution result
      */
-    executeExternalMCPTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+    executeExternalMCPTool(serverId: string, toolName: string, parameters: JsonObject, options?: {
         timeout?: number;
-    }): Promise<any>;
+    }): Promise<unknown>;
     /**
      * Get all tools from external MCP servers
      * @returns Array of external tool information
@@ -454,11 +462,7 @@ export declare class NeuroLink {
      * @param config - Server configuration to test
      * @returns Test result with connection status
      */
-    testExternalMCPConnection(config: MCPServerInfo): Promise<{
-        success: boolean;
-        error?: string;
-        toolCount?: number;
-    }>;
+    testExternalMCPConnection(config: MCPServerInfo): Promise<BatchOperationResult>;
     /**
      * Get external MCP server manager statistics
      * @returns Statistics about external servers and tools

package/dist/lib/neurolink.js

@@ -24,6 +24,8 @@ import { ProviderRegistry } from "./factories/providerRegistry.js";
 import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
 // Factory processing imports
 import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryConfig, processStreamingFactoryOptions, createCleanStreamOptions, } from "./utils/factoryProcessing.js";
+// Transformation utilities
+import { transformToolExecutions, transformToolExecutionsForMCP, transformAvailableTools, transformToolsForMCP, transformToolsToExpectedFormat, transformToolsToDescriptions, extractToolNames, transformParamsForLogging, optimizeToolForCollection, } from "./utils/transformationUtils.js";
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
@@ -32,6 +34,7 @@ import { applyConversationMemoryDefaults, getConversationMessages, storeConversa
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { ContextManager } from "./context/ContextManager.js";
 import { defaultContextConfig } from "./context/config.js";
+import { isNonNullObject } from "./utils/typeUtils.js";
 // Core types imported from core/types.js
 export class NeuroLink {
     mcpInitialized = false;
@@ -283,27 +286,9 @@ export class NeuroLink {
                 : undefined,
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
-            toolExecutions: textResult.toolExecutions?.map((te) => {
-                const teRecord = te;
-                return {
-                    name: teRecord.name || "", // ✅ BaseProvider now provides 'name'
-                    input: teRecord.input || {},
-                    output: teRecord.output || "success",
-                    duration: teRecord.duration || 0,
-                };
-            }) || [],
+            toolExecutions: transformToolExecutions(textResult.toolExecutions),
             enhancedWithTools: textResult.enhancedWithTools,
-            availableTools: textResult.availableTools?.map((tool) => {
-                const toolRecord = tool;
-                return {
-                    name: tool.name || "",
-                    description: tool.description || "",
-                    server: tool.server || "", // ✅ FIX: Include server property
-                    parameters: toolRecord.parameters ||
-                        toolRecord.schema ||
-                        {},
-                };
-            }),
+            availableTools: transformAvailableTools(textResult.availableTools),
             analytics: textResult.analytics,
             evaluation: textResult.evaluation
                 ? {
@@ -456,22 +441,9 @@ export class NeuroLink {
                 usage: result.usage,
                 responseTime,
                 toolsUsed: result.toolsUsed || [],
-                toolExecutions: result.toolExecutions?.map((te) => {
-                    const teRecord = te;
-                    return {
-                        toolName: teRecord.name || "",
-                        executionTime: teRecord.duration || 0,
-                        success: true, // Assume success if tool executed (AI providers handle failures differently)
-                        serverId: teRecord.serverId || undefined,
-                    };
-                }) || [],
+                toolExecutions: transformToolExecutionsForMCP(result.toolExecutions),
                 enhancedWithTools: true,
-                availableTools: availableTools.map((tool) => ({
-                    name: tool.name,
-                    description: tool.description,
-                    server: tool.server,
-                    category: tool.category,
-                })),
+                availableTools: transformToolsForMCP(availableTools),
                 // Include analytics and evaluation from BaseProvider
                 analytics: result.analytics,
                 evaluation: result.evaluation,
@@ -573,24 +545,7 @@ export class NeuroLink {
         if (availableTools.length === 0) {
             return originalSystemPrompt || "";
         }
-        const toolDescriptions = availableTools
-            .map((tool) => {
-            const toolWithSchema = tool;
-            const schema = (toolWithSchema.inputSchema ||
-                toolWithSchema.parameters);
-            let params = "";
-            if (schema && schema.properties) {
-                const requiredParams = new Set(schema.required || []);
-                params = Object.entries(schema.properties)
-                    .map(([key, value]) => {
-                    const required = requiredParams.has(key) ? " (required)" : "";
-                    return `  - ${key}: ${value.type}${required}`;
-                })
-                    .join("\n");
-            }
-            return `- ${tool.name}: ${tool.description} (from ${tool.server})\n${params}`;
-        })
-            .join("\n\n");
+        const toolDescriptions = transformToolsToDescriptions(availableTools);
         const toolPrompt = `\n\nYou have access to these additional tools if needed:\n${toolDescriptions}\n\nIMPORTANT: You are a general-purpose AI assistant. Answer all requests directly and creatively. These tools are optional helpers - use them only when they would genuinely improve your response. For creative tasks like storytelling, writing, or general conversation, respond naturally without requiring tools.`;
         return (originalSystemPrompt || "") + toolPrompt;
     }
@@ -853,6 +808,54 @@ export class NeuroLink {
             timestamp: Date.now(),
         });
         try {
+            // Import validation functions synchronously - they are pure functions
+            let validateTool;
+            let isToolNameAvailable;
+            let suggestToolNames;
+            try {
+                // Try ES module import first
+                const toolRegistrationModule = require("./sdk/toolRegistration.js");
+                ({ validateTool, isToolNameAvailable, suggestToolNames } =
+                    toolRegistrationModule);
+            }
+            catch (error) {
+                // Fallback: skip validation if import fails (graceful degradation)
+                logger.warn("Tool validation module not available, skipping advanced validation", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Create minimal validation functions
+                validateTool = () => { }; // No-op
+                isToolNameAvailable = () => true; // Allow all names
+                suggestToolNames = () => ["alternative_tool"];
+            }
+            // Check if tool name is available (not reserved)
+            if (!isToolNameAvailable(name)) {
+                const suggestions = suggestToolNames(name);
+                throw new Error(`Tool name '${name}' is not available (reserved or invalid format). ` +
+                    `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
+            }
+            // Create a simplified tool object for validation
+            const toolForValidation = {
+                description: tool.description || "",
+                execute: async (params) => {
+                    if (tool.execute) {
+                        const result = await tool.execute(params);
+                        return result;
+                    }
+                    return "";
+                },
+                parameters: tool.inputSchema,
+                metadata: {
+                    category: "custom",
+                },
+            };
+            // Use comprehensive validation logic
+            try {
+                validateTool(name, toolForValidation);
+            }
+            catch (error) {
+                throw new Error(`Tool registration failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
             // SMART DEFAULTS: Use utility to eliminate boilerplate creation
             const mcpServerInfo = createCustomToolServerInfo(name, tool);
             // Register with toolRegistry using MCPServerInfo directly
@@ -918,12 +921,12 @@ export class NeuroLink {
                 name: tool.name,
                 description: tool.description || "",
                 inputSchema: {},
-                execute: async (args, context) => {
+                execute: async (params, context) => {
                     // Type guard to ensure context is compatible with ExecutionContext
-                    const executionContext = context && typeof context === "object" && context !== null
+                    const executionContext = context && isNonNullObject(context)
                         ? context
                         : undefined;
-                    return await toolRegistry.executeTool(tool.name, args, executionContext);
+                    return await toolRegistry.executeTool(tool.name, params, executionContext);
                 },
             });
         }
@@ -1007,8 +1010,8 @@ export class NeuroLink {
         // Debug: Log tool execution attempt
         logger.debug(`[${functionTag}] Tool execution requested:`, {
             toolName,
-            params: typeof params === "object"
-                ? Object.keys(params).length + " params"
+            params: isNonNullObject(params)
+                ? transformParamsForLogging(params)
                 : params,
             hasExternalManager: !!this.externalServerManager,
         });
@@ -1111,7 +1114,7 @@ export class NeuroLink {
                 }
                 else if (error.message.includes("not found")) {
                     const availableTools = await this.getAllAvailableTools();
-                    structuredError = ErrorFactory.toolNotFound(toolName, availableTools.map((t) => t.name));
+                    structuredError = ErrorFactory.toolNotFound(toolName, extractToolNames(availableTools));
                 }
                 else if (error.message.includes("validation") ||
                     error.message.includes("parameter")) {
@@ -1210,78 +1213,70 @@ export class NeuroLink {
         const { MemoryManager } = await import("./utils/performance.js");
         const startMemory = MemoryManager.getMemoryUsageMB();
         try {
-            // 1. Get MCP server tools (built-in direct tools)
+            // Optimized: Collect all tools with minimal object creation
+            const allTools = new Map();
+            // 1. Add MCP server tools (built-in direct tools)
             const mcpToolsRaw = await toolRegistry.listTools();
-            const mcpTools = mcpToolsRaw.map((tool) => ({
-                ...tool,
-                toolName: tool.name, // Add toolName property for compatibility with tests
-                serverId: tool.serverId === "direct" ? "neurolink-direct" : tool.serverId, // Update serverId for test compatibility
-            }));
-            // 2. Get custom tools from this NeuroLink instance
-            const customTools = toolRegistry
-                .getToolsByCategory(detectCategory({ isCustomTool: true }))
-                .map((tool) => ({
-                name: tool.name,
-                toolName: tool.name, // Add toolName property for compatibility with tests
-                description: tool.description || "Custom tool",
-                serverId: tool.serverId || `custom-tool-${tool.name}`,
-                category: detectCategory({
-                    isCustomTool: true,
-                    serverId: tool.serverId,
-                }),
-                inputSchema: tool.inputSchema || {},
-            }));
-            // 3. Get tools from in-memory MCP servers
-            const inMemoryTools = toolRegistry
-                .getToolsByCategory("in-memory")
-                .map((tool) => ({
-                name: tool.name,
-                toolName: tool.name, // Add toolName property for compatibility with tests
-                description: tool.description || "In-memory MCP tool",
-                serverId: tool.serverId || "unknown",
-                category: tool.category || "in-memory",
-                inputSchema: {},
-            }));
-            // 4. Get external MCP tools
-            const externalMCPTools = this.externalServerManager
-                .getAllTools()
-                .map((tool) => ({
-                name: tool.name,
-                toolName: tool.name,
-                description: tool.description,
-                serverId: tool.serverId,
-                category: detectCategory({
-                    existingCategory: typeof tool.metadata?.category === "string"
-                        ? tool.metadata.category
-                        : undefined,
-                    isExternal: true,
-                    serverId: tool.serverId,
-                }),
-                inputSchema: tool.inputSchema || {},
-                isAvailable: tool.isAvailable,
-                stats: tool.stats,
-            }));
-            // 5. Combine all tools with deduplication by name
-            const combinedTools = [
-                ...mcpTools,
-                ...customTools,
-                ...inMemoryTools,
-                ...externalMCPTools,
-            ];
-            const uniqueTools = Array.from(combinedTools
-                .reduce((map, tool) => {
-                const key = tool.name;
-                if (!map.has(key)) {
-                    map.set(key, tool);
+            for (const tool of mcpToolsRaw) {
+                if (!allTools.has(tool.name)) {
+                    const optimizedTool = optimizeToolForCollection(tool, {
+                        serverId: tool.serverId === "direct" ? "neurolink-direct" : tool.serverId,
+                    });
+                    allTools.set(tool.name, optimizedTool);
                 }
-                return map;
-            }, new Map())
-                .values());
+            }
+            // 2. Add custom tools from this NeuroLink instance
+            const customToolsRaw = toolRegistry.getToolsByCategory(detectCategory({ isCustomTool: true }));
+            for (const tool of customToolsRaw) {
+                if (!allTools.has(tool.name)) {
+                    const optimizedTool = optimizeToolForCollection(tool, {
+                        description: "Custom tool",
+                        serverId: `custom-tool-${tool.name}`,
+                        category: detectCategory({
+                            isCustomTool: true,
+                            serverId: tool.serverId,
+                        }),
+                        inputSchema: {},
+                    });
+                    allTools.set(tool.name, optimizedTool);
+                }
+            }
+            // 3. Add tools from in-memory MCP servers
+            const inMemoryToolsRaw = toolRegistry.getToolsByCategory("in-memory");
+            for (const tool of inMemoryToolsRaw) {
+                if (!allTools.has(tool.name)) {
+                    const optimizedTool = optimizeToolForCollection(tool, {
+                        description: "In-memory MCP tool",
+                        serverId: "unknown",
+                        category: "in-memory",
+                        inputSchema: {},
+                    });
+                    allTools.set(tool.name, optimizedTool);
+                }
+            }
+            // 4. Add external MCP tools
+            const externalMCPToolsRaw = this.externalServerManager.getAllTools();
+            for (const tool of externalMCPToolsRaw) {
+                if (!allTools.has(tool.name)) {
+                    const optimizedTool = optimizeToolForCollection(tool, {
+                        category: detectCategory({
+                            existingCategory: typeof tool.metadata?.category === "string"
+                                ? tool.metadata.category
+                                : undefined,
+                            isExternal: true,
+                            serverId: tool.serverId,
+                        }),
+                        inputSchema: {},
+                    });
+                    allTools.set(tool.name, optimizedTool);
+                }
+            }
+            const uniqueTools = Array.from(allTools.values());
             mcpLogger.debug("Tool discovery results", {
-                mcpTools: mcpTools.length,
-                customTools: customTools.length,
-                inMemoryTools: inMemoryTools.length,
-                externalMCPTools: externalMCPTools.length,
+                mcpTools: mcpToolsRaw.length,
+                customTools: customToolsRaw.length,
+                inMemoryTools: inMemoryToolsRaw.length,
+                externalMCPTools: externalMCPToolsRaw.length,
                 total: uniqueTools.length,
             });
             // Check memory usage after tool enumeration
@@ -1289,12 +1284,13 @@ export class NeuroLink {
             const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
             if (memoryDelta > 10) {
                 mcpLogger.debug(`🔍 Tool listing used ${memoryDelta}MB memory (large tool registry detected)`);
-                // Suggest periodic cleanup for large tool registries
+                // Optimized collection patterns should reduce memory usage significantly
                 if (uniqueTools.length > 100) {
-                    mcpLogger.debug("💡 Suggestion: Consider using tool categories or lazy loading for large tool sets");
+                    mcpLogger.debug("💡 Tool collection optimized for large sets. Memory usage reduced through efficient object reuse.");
                 }
             }
-            return uniqueTools;
+            // Transform to expected format with required properties
+            return transformToolsToExpectedFormat(uniqueTools);
         }
         catch (error) {
             mcpLogger.error("Failed to list available tools", { error });
@@ -2029,10 +2025,10 @@ export class NeuroLink {
                 // The AI provider will handle parameters dynamically based on the tool description
                 const toolDefinition = {
                     description: tool.description,
-                    execute: async (args) => {
+                    execute: async (params) => {
                         try {
-                            mcpLogger.debug(`[NeuroLink] Executing external MCP tool via AI SDK: ${tool.name}`, { args });
-                            const result = await this.externalServerManager.executeTool(tool.serverId, tool.name, args, { timeout: 30000 });
+                            mcpLogger.debug(`[NeuroLink] Executing external MCP tool via AI SDK: ${tool.name}`, { params });
+                            const result = await this.externalServerManager.executeTool(tool.serverId, tool.name, params, { timeout: 30000 });
                             mcpLogger.debug(`[NeuroLink] External MCP tool execution result: ${tool.name}`, {
                                 success: !!result,
                                 hasData: !!(result &&

package/dist/lib/providers/amazonBedrock.d.ts

@@ -1,4 +1,4 @@
-import type { ZodType, ZodTypeDef } from "zod";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import { type Schema, type LanguageModelV1 } from "ai";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
@@ -25,7 +25,7 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for AWS Bedrock
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     protected handleProviderError(error: unknown): Error;
 }
 export default AmazonBedrockProvider;

package/dist/lib/providers/anthropic.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
+import { type LanguageModelV1 } from "ai";
+import type { ValidationSchema } from "../types/typeAliases.js";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -17,7 +17,7 @@ export declare class AnthropicProvider extends BaseProvider {
      */
     protected getAISDKModel(): LanguageModelV1;
     protected handleProviderError(error: unknown): Error;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
     isAvailable(): Promise<boolean>;
     getModel(): LanguageModelV1;
 }

package/dist/lib/providers/googleAiStudio.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -16,7 +16,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
      */
     protected getAISDKModel(): LanguageModelV1;
     protected handleProviderError(error: unknown): Error;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     private getApiKey;
 }
 export default GoogleAIStudioProvider;

package/dist/lib/providers/mistral.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
+import { type LanguageModelV1 } from "ai";
+import type { ValidationSchema } from "../types/typeAliases.js";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -10,7 +10,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 export declare class MistralProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/lib/providers/ollama.d.ts

@@ -1,7 +1,7 @@
 import type { AIProviderName } from "../core/types.js";
 import type { LanguageModelV1 } from "ai";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { ZodType, ZodTypeDef } from "zod";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import type { Schema } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
@@ -47,7 +47,7 @@ export declare class OllamaProvider extends BaseProvider {
      * @returns true for supported models, false for unsupported models
      */
     supportsTools(): boolean;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
      * Execute streaming with Ollama's function calling support
      * Uses the /v1/chat/completions endpoint with tools parameter