@juspay/neurolink 7.33.0 → 7.33.2

package/dist/lib/types/streamTypes.d.ts

@@ -1,26 +1,65 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
-import type { AIProviderName, AnalyticsData } from "../core/types.js";
-import type { EvaluationData } from "../index.js";
-import type { TokenUsage } from "./providers.js";
+import type { AIProviderName, ProviderConfig } from "./providers.js";
+import type { AnalyticsData, TokenUsage } from "./analytics.js";
+import type { EvaluationData } from "./evaluation.js";
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { ChatMessage } from "./conversationTypes.js";
-import type { MiddlewareFactoryOptions } from "../types/middlewareTypes.js";
+import type { MiddlewareFactoryOptions } from "./middlewareTypes.js";
 /**
- * Interface for tool execution calls (AI SDK compatible)
+ * Progress tracking and metadata for streaming operations
  */
-export interface ToolCall {
+export type StreamingProgressData = {
+    chunkCount: number;
+    totalBytes: number;
+    chunkSize: number;
+    elapsedTime: number;
+    estimatedRemaining?: number;
+    streamId?: string;
+    phase: "initializing" | "streaming" | "processing" | "complete" | "error";
+};
+/**
+ * Streaming metadata for performance tracking
+ */
+export type StreamingMetadata = {
+    startTime: number;
+    endTime?: number;
+    totalDuration?: number;
+    averageChunkSize: number;
+    maxChunkSize: number;
+    minChunkSize: number;
+    throughputBytesPerSecond?: number;
+    streamingProvider: string;
+    modelUsed: string;
+};
+/**
+ * Options for AI requests with unified provider configuration
+ */
+export type StreamingOptions = {
+    providers: ProviderConfig[];
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+};
+/**
+ * Progress callback for streaming operations
+ */
+export type ProgressCallback = (progress: StreamingProgressData) => void | Promise<void>;
+/**
+ * Type for tool execution calls (AI SDK compatible)
+ */
+export type ToolCall = {
     type?: "tool-call";
     toolCallId?: string;
     toolName: string;
     parameters?: UnknownRecord;
     args?: UnknownRecord;
     id?: string;
-}
+};
 /**
- * Interface for tool execution results - Enhanced for type safety
+ * Type for tool execution results - Enhanced for type safety
  */
-export interface ToolResult {
+export type ToolResult = {
     toolName: string;
     status: "success" | "failure";
     output?: JsonValue;
@@ -34,7 +73,7 @@ export interface ToolResult {
         toolCategory?: string;
         isExternal?: boolean;
     };
-}
+};
 /**
  * Tool Call Results Array - High Reusability
  */
@@ -46,7 +85,7 @@ export type ToolCalls = Array<ToolCall>;
 /**
  * Stream Analytics Data - Enhanced for performance tracking
  */
-export interface StreamAnalyticsData {
+export type StreamAnalyticsData = {
     /** Tool execution results with timing */
     toolResults?: Promise<ToolCallResults>;
     /** Tool calls made during stream */
@@ -61,9 +100,9 @@ export interface StreamAnalyticsData {
     };
     /** Provider analytics */
     providerAnalytics?: AnalyticsData;
-}
+};
 /**
- * Stream function options interface - Primary method for streaming content
+ * Stream function options type - Primary method for streaming content
  * Future-ready for multi-modal capabilities while maintaining text focus
  */
 export type PCMEncoding = "PCM16LE";
@@ -79,7 +118,7 @@ export interface AudioChunk {
     channels: number;
     encoding: PCMEncoding;
 }
-export interface StreamOptions {
+export type StreamOptions = {
     input: {
         text?: string;
         audio?: AudioInputSpec;
@@ -127,12 +166,12 @@ export interface StreamOptions {
     };
     conversationMessages?: ChatMessage[];
     middleware?: MiddlewareFactoryOptions;
-}
+};
 /**
- * Stream function result interface - Primary output format for streaming
+ * Stream function result type - Primary output format for streaming
  * Future-ready for multi-modal outputs while maintaining text focus
  */
-export interface StreamResult {
+export type StreamResult = {
     stream: AsyncIterable<{
         content: string;
     } | {
@@ -155,12 +194,53 @@ export interface StreamResult {
     };
     analytics?: AnalyticsData | Promise<AnalyticsData>;
     evaluation?: EvaluationData | Promise<EvaluationData>;
-}
+};
 /**
- * Enhanced provider interface with stream method
+ * Enhanced provider type with stream method
  */
-export interface EnhancedStreamProvider {
+export type EnhancedStreamProvider = {
     stream(options: StreamOptions): Promise<StreamResult>;
     getName(): string;
     isAvailable(): Promise<boolean>;
-}
+};
+/**
+ * Stream text result from AI SDK
+ */
+export type StreamTextResult = {
+    textStream: AsyncIterable<string>;
+    text: Promise<string>;
+    usage: Promise<AISDKUsage | undefined>;
+    response: Promise<{
+        id?: string;
+        model?: string;
+        timestamp?: number | Date;
+    } | undefined>;
+    finishReason: Promise<"stop" | "length" | "content-filter" | "tool-calls" | "error" | "other" | "unknown">;
+    toolResults?: Promise<ToolResult[]>;
+    toolCalls?: Promise<ToolCall[]>;
+};
+/**
+ * Raw usage data from Vercel AI SDK
+ */
+export type AISDKUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+};
+/**
+ * Stream analytics collector type
+ */
+export type StreamAnalyticsCollector = {
+    collectUsage(result: StreamTextResult): Promise<TokenUsage>;
+    collectMetadata(result: StreamTextResult): Promise<ResponseMetadata>;
+    createAnalytics(provider: string, model: string, result: StreamTextResult, startTime: number, context?: Record<string, unknown>): Promise<AnalyticsData>;
+};
+/**
+ * Response metadata from stream
+ */
+export type ResponseMetadata = {
+    id?: string;
+    model?: string;
+    timestamp?: number | Date;
+    finishReason?: string;
+};

package/dist/lib/utils/analyticsUtils.d.ts

@@ -2,7 +2,7 @@
  * Analytics utility functions for TokenUsage and AnalyticsData
  * Provides helper functions to avoid manual field access patterns
  */
-import type { TokenUsage, AnalyticsData } from "../types/providers.js";
+import type { TokenUsage, AnalyticsData } from "../types/index.js";
 /**
  * Format token usage as a human-readable string
  */
@@ -31,3 +31,7 @@ export declare function getAnalyticsSummary(analytics: AnalyticsData): {
     costPerToken: number | null;
     requestsPerSecond: number;
 };
+/**
+ * Type guard for token usage
+ */
+export declare function isTokenUsage(value: unknown): value is TokenUsage;

package/dist/lib/utils/analyticsUtils.js

@@ -74,3 +74,16 @@ export function getAnalyticsSummary(analytics) {
         requestsPerSecond,
     };
 }
+/**
+ * Type guard for token usage
+ */
+export function isTokenUsage(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "input" in value &&
+        "output" in value &&
+        "total" in value &&
+        typeof value.input === "number" &&
+        typeof value.output === "number" &&
+        typeof value.total === "number");
+}

package/dist/lib/utils/conversationMemoryUtils.d.ts

@@ -4,7 +4,7 @@
  */
 import type { ConversationMemoryConfig, ChatMessage } from "../types/conversationTypes.js";
 import type { ConversationMemoryManager } from "../core/conversationMemoryManager.js";
-import type { TextGenerationOptions, TextGenerationResult } from "../core/types.js";
+import type { TextGenerationOptions, TextGenerationResult } from "../types/index.js";
 /**
  * Apply conversation memory defaults to user configuration
  * Merges user config with environment variables and default values

package/dist/lib/utils/evaluationUtils.d.ts

@@ -3,7 +3,7 @@
  * Provides helper functions to handle partial evaluation data and ensure
  * complete EvaluationData objects with safe defaults
  */
-import type { EvaluationData } from "../types/providers.js";
+import type { EvaluationData } from "../types/evaluation.js";
 /**
  * Normalize partial EvaluationData into a complete EvaluationData object
  * with safe defaults for missing required fields

package/dist/lib/utils/factoryProcessing.d.ts

@@ -5,7 +5,7 @@
  */
 import type { GenerateOptions } from "../types/generateTypes.js";
 import type { StreamOptions } from "../types/streamTypes.js";
-import type { TextGenerationOptions } from "../core/types.js";
+import type { TextGenerationOptions } from "../types/index.js";
 import type { UnknownRecord, JsonValue } from "../types/common.js";
 import type { StandardRecord } from "../types/typeAliases.js";
 /**

package/dist/lib/utils/messageBuilder.d.ts

@@ -3,7 +3,7 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  */
 import type { ChatMessage } from "../types/conversationTypes.js";
-import type { TextGenerationOptions } from "../core/types.js";
+import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 /**
  * Build a properly formatted message array for AI providers

package/dist/lib/utils/providerHealth.d.ts

@@ -2,7 +2,7 @@
  * Provider Health Checking System
  * Prevents 500 errors by validating provider availability and configuration
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 export interface ProviderHealthStatus {
     provider: AIProviderName;
     isHealthy: boolean;

package/dist/lib/utils/providerHealth.js

@@ -3,7 +3,7 @@
  * Prevents 500 errors by validating provider availability and configuration
  */
 import { logger } from "./logger.js";
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import { basename } from "path";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 export class ProviderHealthChecker {

package/dist/lib/utils/providerUtils.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderError } from "../types/index.js";
 /**
  * Get the best available provider based on real-time availability checks
  * Enhanced version consolidated from providerUtils-fixed.ts
@@ -40,3 +41,7 @@ export declare function getAvailableProviders(): string[];
  * @returns True if provider name is valid
  */
 export declare function isValidProvider(provider: string): boolean;
+/**
+ * Type guard for provider error
+ */
+export declare function isProviderError(error: unknown): error is ProviderError;

package/dist/lib/utils/providerUtils.js

@@ -434,3 +434,9 @@ export function getAvailableProviders() {
 export function isValidProvider(provider) {
     return getAvailableProviders().includes(provider.toLowerCase());
 }
+/**
+ * Type guard for provider error
+ */
+export function isProviderError(error) {
+    return error instanceof Error && "provider" in error;
+}

package/dist/mcp/externalServerManager.d.ts

@@ -22,12 +22,27 @@ export declare class ExternalServerManager extends EventEmitter {
         enableMainRegistryIntegration?: boolean;
     });
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * Automatically registers servers found in the configuration
      * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
-     * @returns Promise resolving to number of servers loaded
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    loadMCPConfiguration(configPath?: string): Promise<ServerLoadResult>;
+    loadMCPConfiguration(configPath?: string, options?: {
+        parallel?: boolean;
+    }): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationParallel(configPath?: string | null): Promise<ServerLoadResult>;
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    loadMCPConfigurationSequential(configPath?: string): Promise<ServerLoadResult>;
     /**
      * Validate external MCP server configuration
      */

package/dist/mcp/externalServerManager.js

@@ -107,12 +107,134 @@ export class ExternalServerManager extends EventEmitter {
         process.on("beforeExit", () => this.shutdown());
     }
     /**
-     * Load MCP server configurations from .mcp-config.json file
+     * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * Automatically registers servers found in the configuration
      * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
-     * @returns Promise resolving to number of servers loaded
+     * @param options Loading options including parallel support
+     * @returns Promise resolving to { serversLoaded, errors }
      */
-    async loadMCPConfiguration(configPath) {
+    async loadMCPConfiguration(configPath, options = {}) {
+        if (options.parallel) {
+            return this.loadMCPConfigurationParallel(configPath);
+        }
+        return this.loadMCPConfigurationSequential(configPath);
+    }
+    /**
+     * Load MCP servers in parallel for improved performance
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationParallel(configPath) {
+        const fs = await import("fs");
+        const path = await import("path");
+        const finalConfigPath = configPath || path.join(process.cwd(), ".mcp-config.json");
+        if (!fs.existsSync(finalConfigPath)) {
+            mcpLogger.debug(`[ExternalServerManager] No MCP config found at ${finalConfigPath}`);
+            return { serversLoaded: 0, errors: [] };
+        }
+        mcpLogger.debug(`[ExternalServerManager] Loading MCP configuration in PARALLEL mode from ${finalConfigPath}`);
+        try {
+            const configContent = fs.readFileSync(finalConfigPath, "utf8");
+            const config = JSON.parse(configContent);
+            if (!config.mcpServers || typeof config.mcpServers !== "object") {
+                mcpLogger.debug("[ExternalServerManager] No mcpServers found in configuration");
+                return { serversLoaded: 0, errors: [] };
+            }
+            // Create promises for all servers to start them concurrently
+            const serverPromises = Object.entries(config.mcpServers).map(async ([serverId, serverConfig]) => {
+                try {
+                    // Validate and convert config format to MCPServerInfo
+                    if (!isValidExternalMCPServerConfig(serverConfig)) {
+                        throw new Error(`Invalid server config for ${serverId}: missing required properties or wrong types`);
+                    }
+                    const externalConfig = {
+                        id: serverId,
+                        name: serverId,
+                        description: `External MCP server: ${serverId}`,
+                        transport: typeof serverConfig.transport === "string"
+                            ? serverConfig.transport
+                            : "stdio",
+                        status: "initializing",
+                        tools: [],
+                        command: serverConfig.command,
+                        args: Array.isArray(serverConfig.args)
+                            ? serverConfig.args
+                            : [],
+                        env: isNonNullObject(serverConfig.env)
+                            ? serverConfig.env
+                            : {},
+                        timeout: typeof serverConfig.timeout === "number"
+                            ? serverConfig.timeout
+                            : undefined,
+                        retries: typeof serverConfig.retries === "number"
+                            ? serverConfig.retries
+                            : undefined,
+                        healthCheckInterval: typeof serverConfig.healthCheckInterval === "number"
+                            ? serverConfig.healthCheckInterval
+                            : undefined,
+                        autoRestart: typeof serverConfig.autoRestart === "boolean"
+                            ? serverConfig.autoRestart
+                            : undefined,
+                        cwd: typeof serverConfig.cwd === "string"
+                            ? serverConfig.cwd
+                            : undefined,
+                        url: typeof serverConfig.url === "string"
+                            ? serverConfig.url
+                            : undefined,
+                        metadata: safeMetadataConversion(serverConfig.metadata),
+                    };
+                    const result = await this.addServer(serverId, externalConfig);
+                    return { serverId, result };
+                }
+                catch (error) {
+                    const errorMsg = `Failed to load MCP server ${serverId}: ${error instanceof Error ? error.message : String(error)}`;
+                    mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    return { serverId, error: errorMsg };
+                }
+            });
+            // Start all servers concurrently and wait for completion
+            const results = await Promise.allSettled(serverPromises);
+            // Process results to count successes and collect errors
+            let serversLoaded = 0;
+            const errors = [];
+            for (const result of results) {
+                if (result.status === "fulfilled") {
+                    const { serverId, result: serverResult, error } = result.value;
+                    if (serverResult && serverResult.success) {
+                        serversLoaded++;
+                        mcpLogger.debug(`[ExternalServerManager] Successfully loaded MCP server in parallel: ${serverId}`);
+                    }
+                    else if (error) {
+                        errors.push(error);
+                    }
+                    else if (serverResult && !serverResult.success) {
+                        const errorMsg = `Failed to load server ${serverId}: ${serverResult.error}`;
+                        errors.push(errorMsg);
+                        mcpLogger.warn(`[ExternalServerManager] ${errorMsg}`);
+                    }
+                }
+                else {
+                    // Promise.allSettled rejected - this shouldn't happen with our error handling
+                    const errorMsg = `Unexpected error during parallel loading: ${result.reason}`;
+                    errors.push(errorMsg);
+                    mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+                }
+            }
+            mcpLogger.info(`[ExternalServerManager] PARALLEL MCP configuration loading complete: ${serversLoaded} servers loaded, ${errors.length} errors`);
+            return { serversLoaded, errors };
+        }
+        catch (error) {
+            const errorMsg = `Failed to load MCP configuration in parallel mode: ${error instanceof Error ? error.message : String(error)}`;
+            mcpLogger.error(`[ExternalServerManager] ${errorMsg}`);
+            return { serversLoaded: 0, errors: [errorMsg] };
+        }
+    }
+    /**
+     * Load MCP servers sequentially (original implementation for backward compatibility)
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to batch operation result
+     */
+    async loadMCPConfigurationSequential(configPath) {
         const fs = await import("fs");
         const path = await import("path");
         const finalConfigPath = configPath || path.join(process.cwd(), ".mcp-config.json");

package/dist/models/modelRegistry.d.ts

@@ -3,7 +3,7 @@
  * Provides centralized model data for models command system
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import type { JsonValue } from "../types/common.js";
 /**
  * Model capabilities interface

package/dist/models/modelRegistry.js

@@ -3,7 +3,7 @@
  * Provides centralized model data for models command system
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 /**
  * Comprehensive model registry
  */

package/dist/models/modelResolver.d.ts

@@ -3,7 +3,7 @@
  * Provides model resolution, search, and recommendation functionality
  * Part of Phase 4.1 - Models Command System
  */
-import { AIProviderName } from "../core/types.js";
+import { AIProviderName } from "../types/index.js";
 import type { JsonValue } from "../types/common.js";
 import { type ModelInfo, type ModelSearchFilters, type ModelSearchResult, type ModelCapabilities, type UseCaseSuitability } from "./modelRegistry.js";
 /**

package/dist/neurolink.d.ts

@@ -5,7 +5,7 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { TextGenerationOptions, TextGenerationResult } from "./core/types.js";
+import type { TextGenerationOptions, TextGenerationResult } from "./types/index.js";
 import type { GenerateOptions, GenerateResult } from "./types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "./types/streamTypes.js";
 import type { MCPServerInfo, MCPExecutableTool } from "./types/mcpTypes.js";
@@ -146,7 +146,7 @@ export declare class NeuroLink {
      */
     private registerDirectToolsServerInternal;
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     private loadMCPConfigurationInternal;
     /**

package/dist/neurolink.js

@@ -36,7 +36,7 @@ import { ExternalServerManager } from "./mcp/externalServerManager.js";
 // Import direct tools server for automatic registration
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { isNonNullObject } from "./utils/typeUtils.js";
-// Core types imported from core/types.js
+// Core types imported from "./types/index.js"
 export class NeuroLink {
     mcpInitialized = false;
     emitter = new EventEmitter();
@@ -705,7 +705,7 @@ export class NeuroLink {
         }
     }
     /**
-     * Load MCP configuration from .mcp-config.json
+     * Load MCP configuration from .mcp-config.json with parallel loading for improved performance
      */
     async loadMCPConfigurationInternal(mcpInitId, mcpInitStartTime, mcpInitHrTimeStart) {
         const mcpConfigStartTime = process.hrtime.bigint();
@@ -720,7 +720,8 @@ export class NeuroLink {
             message: "Starting MCP configuration loading from .mcp-config.json",
         });
         try {
-            const configResult = await this.externalServerManager.loadMCPConfiguration();
+            const configResult = await this.externalServerManager.loadMCPConfiguration(undefined, // Use default config path
+            { parallel: true });
             const mcpConfigSuccessTime = process.hrtime.bigint();
             const mcpConfigDurationNs = mcpConfigSuccessTime - mcpConfigStartTime;
             logger.debug(`[NeuroLink] ✅ LOG_POINT_M015_MCP_CONFIG_SUCCESS`, {

package/dist/providers/amazonBedrock.d.ts

@@ -1,8 +1,7 @@
 import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { AIProviderName, EnhancedGenerateResult } from "../core/types.js";
+import type { AIProviderName, EnhancedGenerateResult, TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { TextGenerationOptions } from "../core/types.js";
 import type { NeuroLink } from "../neurolink.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;

package/dist/providers/amazonSagemaker.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema, LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/anthropic.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModelV1 } from "ai";
 import type { ValidationSchema } from "../types/typeAliases.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/anthropic.js

@@ -1,6 +1,6 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
-import { AnthropicModels } from "../core/types.js";
+import { AnthropicModels } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";

package/dist/providers/anthropicBaseProvider.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/anthropicBaseProvider.js

@@ -1,6 +1,6 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
-import { AnthropicModels } from "../core/types.js";
+import { AnthropicModels } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";

package/dist/providers/azureOpenai.d.ts

@@ -1,6 +1,6 @@
 import { type LanguageModelV1 } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 export declare class AzureOpenAIProvider extends BaseProvider {
     private apiKey;

package/dist/providers/googleAiStudio.d.ts

@@ -1,6 +1,6 @@
 import { type Schema, type LanguageModelV1 } from "ai";
 import type { ZodUnknownSchema } from "../types/typeAliases.js";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**

package/dist/providers/googleAiStudio.js

@@ -1,6 +1,6 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
-import { GoogleAIModels } from "../core/types.js";
+import { GoogleAIModels } from "../types/index.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";

package/dist/providers/googleVertex.d.ts

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1, type LanguageModel } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import type { AIProviderName } from "../types/index.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**