@juspay/neurolink 7.14.2 → 7.14.4

package/dist/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/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/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/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/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/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/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/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

package/dist/providers/openAI.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 { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -23,6 +23,6 @@ export declare class OpenAIProvider extends BaseProvider {
      * For details on the changes and migration steps, refer to the BaseProvider documentation
      * and the migration guide in the project repository.
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ValidationSchema): Promise<StreamResult>;
 }
 export default OpenAIProvider;

package/dist/providers/openaiCompatible.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";
@@ -29,7 +29,7 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from OpenAI Compatible endpoint
      *

package/dist/providers/sagemaker/client.d.ts

@@ -5,6 +5,7 @@
  * with enhanced error handling, retry logic, and NeuroLink-specific features.
  */
 import type { SageMakerConfig, InvokeEndpointParams, InvokeEndpointResponse } from "./types.js";
+import type { ConnectionResult } from "../../types/typeAliases.js";
 /**
  * Enhanced SageMaker Runtime client with retry logic and error handling
  */
@@ -149,8 +150,4 @@ export declare function createSageMakerRuntimeClient(config: SageMakerConfig): S
  * @param endpointName - Endpoint to test
  * @returns Promise resolving to connectivity test result
  */
-export declare function testSageMakerConnectivity(config: SageMakerConfig, endpointName: string): Promise<{
-    connected: boolean;
-    latency?: number;
-    error?: string;
-}>;
+export declare function testSageMakerConnectivity(config: SageMakerConfig, endpointName: string): Promise<ConnectionResult>;

package/dist/providers/sagemaker/language-model.d.ts

@@ -6,6 +6,7 @@
  */
 import type { LanguageModelV1, LanguageModelV1CallOptions, LanguageModelV1StreamPart } from "ai";
 import type { SageMakerConfig, SageMakerModelConfig } from "./types.js";
+import type { ConnectivityResult } from "../../types/typeAliases.js";
 /**
  * SageMaker Language Model implementing LanguageModelV1 interface
  */
@@ -125,16 +126,13 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
     /**
      * Test basic connectivity to the SageMaker endpoint
      */
-    testConnectivity(): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
+    testConnectivity(): Promise<ConnectivityResult>;
     /**
      * Batch inference support (Phase 4)
      * Process multiple prompts in a single request for efficiency
@@ -175,7 +173,7 @@ export declare class SageMakerLanguageModel implements LanguageModelV1 {
         provider: string;
         specificationVersion: string;
         endpointName: string;
-        modelType: "huggingface" | "mistral" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
+        modelType: "mistral" | "huggingface" | "custom" | "claude" | "llama" | "jumpstart" | undefined;
         region: string;
     };
 }

package/dist/providers/sagemaker/parsers.js

@@ -4,6 +4,7 @@
  * This module provides protocol-specific parsers for different streaming
  * formats used by SageMaker endpoints (HuggingFace, LLaMA, custom models).
  */
+import { isNonNullObject } from "../../utils/typeUtils.js";
 import { createStructuredOutputParser, isStructuredContent, } from "./structured-parser.js";
 import { SageMakerError } from "./errors.js";
 import { logger } from "../../utils/logger.js";
@@ -229,7 +230,7 @@ export class HuggingFaceStreamParser extends BaseStreamingParser {
                 }
                 // Parse JSON data
                 const parsed = this.parseJSON(data);
-                if (parsed && typeof parsed === "object" && parsed !== null) {
+                if (parsed && isNonNullObject(parsed)) {
                     const chunk = this.parseHuggingFaceChunk(parsed);
                     if (chunk) {
                         chunks.push(chunk);
@@ -310,7 +311,7 @@ export class LlamaStreamParser extends BaseStreamingParser {
             }
             // Parse each line as JSON
             const parsed = this.parseJSON(trimmed);
-            if (parsed && typeof parsed === "object" && parsed !== null) {
+            if (parsed && isNonNullObject(parsed)) {
                 const chunk = this.parseLlamaChunk(parsed);
                 if (chunk) {
                     chunks.push(chunk);
@@ -512,7 +513,7 @@ export class CustomStreamParser extends BaseStreamingParser {
                 const line = this.buffer.substring(startIndex, newlineIndex);
                 if (line.trim()) {
                     const parsed = this.parseJSON(line.trim());
-                    if (parsed && typeof parsed === "object" && parsed !== null) {
+                    if (parsed && isNonNullObject(parsed)) {
                         const chunk = this.parseCustomChunk(parsed);
                         if (chunk) {
                             chunks.push(chunk);
@@ -605,7 +606,7 @@ function formatErrorMessage(error) {
  * Handles both string and object error formats consistently
  */
 function extractApiErrorMessage(errorData) {
-    if (typeof errorData === "object" && errorData !== null) {
+    if (isNonNullObject(errorData)) {
         return errorData.message || String(errorData);
     }
     return String(errorData);