@juspay/neurolink 10.12.9 → 11.1.0

package/dist/providers/anthropic/utils.js

@@ -1,149 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { AnthropicModels } from "../../constants/enums.js";
-import { logger } from "../../utils/logger.js";
-import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const getAnthropicApiKey = () => {
-    return validateApiKey(createAnthropicConfig());
-};
-export const getDefaultAnthropicModel = () => {
-    return getProviderModel("ANTHROPIC_MODEL", AnthropicModels.CLAUDE_SONNET_4_6);
-};
-export const getOAuthToken = () => {
-    // First, check stored credentials file (highest priority)
-    try {
-        const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
-        if (existsSync(credentialsPath)) {
-            const credentialsContent = readFileSync(credentialsPath, "utf-8");
-            const credentials = JSON.parse(credentialsContent);
-            if (credentials.type === "oauth" && credentials.oauth?.accessToken) {
-                logger.debug("[AnthropicProvider] Using OAuth token from stored credentials file");
-                return credentials.oauth;
-            }
-        }
-    }
-    catch (error) {
-        logger.debug("[AnthropicProvider] Failed to read stored credentials:", error);
-    }
-    // Fallback to environment variables
-    const tokenString = process.env.ANTHROPIC_OAUTH_TOKEN || process.env.CLAUDE_OAUTH_TOKEN;
-    if (!tokenString) {
-        return null;
-    }
-    // Try to parse as JSON (for full token object with refresh token and expiry)
-    try {
-        const parsed = JSON.parse(tokenString);
-        if (typeof parsed === "object" && parsed.accessToken) {
-            return parsed;
-        }
-        // If it's a simple string in JSON, use it as access token
-        if (typeof parsed === "string") {
-            return { accessToken: parsed };
-        }
-    }
-    catch {
-        // Not JSON, treat as plain access token string
-    }
-    // Treat as plain access token string
-    return { accessToken: tokenString };
-};
-export const detectSubscriptionTier = (oauthToken) => {
-    // Check explicit environment variable first
-    const envTier = process.env.ANTHROPIC_SUBSCRIPTION_TIER?.toLowerCase();
-    if (envTier) {
-        const validTiers = [
-            "free",
-            "pro",
-            "max",
-            "max_5",
-            "max_20",
-            "api",
-        ];
-        if (validTiers.includes(envTier)) {
-            logger.debug("[detectSubscriptionTier] Using environment override", {
-                tier: envTier,
-            });
-            return envTier;
-        }
-        logger.warn("[detectSubscriptionTier] Invalid ANTHROPIC_SUBSCRIPTION_TIER", {
-            value: envTier,
-            validTiers,
-        });
-    }
-    // If using OAuth, default to 'pro' (most common subscription tier)
-    if (oauthToken) {
-        // Check if token scopes indicate tier (future-proofing)
-        const scopes = oauthToken.scopes ?? [];
-        let detectedTier = "pro";
-        if (scopes.includes("max_20")) {
-            detectedTier = "max_20";
-        }
-        else if (scopes.includes("max_5")) {
-            detectedTier = "max_5";
-        }
-        else if (scopes.includes("max")) {
-            detectedTier = "max";
-        }
-        logger.debug("[detectSubscriptionTier] Detected from OAuth token", {
-            tier: detectedTier,
-            scopes,
-        });
-        return detectedTier;
-    }
-    // Default to 'api' for API key authentication
-    logger.debug("[detectSubscriptionTier] No OAuth token, defaulting to API tier");
-    return "api";
-};
-export const detectAuthMethod = (oauthToken) => {
-    // Explicit env var takes highest precedence — allows forcing api_key mode
-    // even when OAuth credentials exist (e.g., when using a proxy that handles auth)
-    const explicit = process.env.ANTHROPIC_AUTH_METHOD?.toLowerCase();
-    if (explicit === "api_key" || explicit === "apikey") {
-        logger.debug("[detectAuthMethod] Forced to api_key by ANTHROPIC_AUTH_METHOD env var");
-        return "api_key";
-    }
-    if (explicit === "oauth") {
-        if (oauthToken) {
-            logger.debug("[detectAuthMethod] Forced to oauth by ANTHROPIC_AUTH_METHOD env var");
-            return "oauth";
-        }
-        logger.warn("[detectAuthMethod] ANTHROPIC_AUTH_METHOD=oauth but no OAuth token found; falling through to auto-detection");
-    }
-    else if (explicit) {
-        logger.warn("[detectAuthMethod] Unrecognized ANTHROPIC_AUTH_METHOD value; falling through to auto-detection", {
-            value: explicit,
-        });
-    }
-    // Auto-detect: OAuth takes precedence if available
-    const method = oauthToken ? "oauth" : "api_key";
-    logger.debug("[detectAuthMethod] Auth method resolved", {
-        method,
-        hasOAuthToken: !!oauthToken,
-    });
-    return method;
-};
-export const parseRateLimitHeaders = (headers) => {
-    const getHeader = (name) => {
-        if (headers instanceof Headers) {
-            return headers.get(name);
-        }
-        return headers[name] || headers[name.toLowerCase()] || null;
-    };
-    const parseNumber = (value) => {
-        if (!value) {
-            return undefined;
-        }
-        const num = parseInt(value, 10);
-        return isNaN(num) ? undefined : num;
-    };
-    return {
-        requestsLimit: parseNumber(getHeader("anthropic-ratelimit-requests-limit")),
-        requestsRemaining: parseNumber(getHeader("anthropic-ratelimit-requests-remaining")),
-        requestsReset: getHeader("anthropic-ratelimit-requests-reset") || undefined,
-        tokensLimit: parseNumber(getHeader("anthropic-ratelimit-tokens-limit")),
-        tokensRemaining: parseNumber(getHeader("anthropic-ratelimit-tokens-remaining")),
-        tokensReset: getHeader("anthropic-ratelimit-tokens-reset") || undefined,
-        retryAfter: parseNumber(getHeader("retry-after")),
-    };
-};

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

@@ -1,2 +0,0 @@
-import type { GenAIClient } from "../../types/index.js";
-export declare function createGoogleGenAIClient(apiKey: string): Promise<GenAIClient>;

package/dist/providers/googleAiStudio/utils.js

@@ -1,18 +0,0 @@
-import { ErrorCategory, ErrorSeverity } from "../../constants/enums.js";
-import { ERROR_CODES, NeuroLinkError } from "../../utils/errorHandling.js";
-export async function createGoogleGenAIClient(apiKey) {
-    const mod = await import("@google/genai");
-    const ctor = mod.GoogleGenAI;
-    if (!ctor) {
-        throw new NeuroLinkError({
-            code: ERROR_CODES.INVALID_CONFIGURATION,
-            message: "@google/genai does not export GoogleGenAI",
-            category: ErrorCategory.CONFIGURATION,
-            severity: ErrorSeverity.CRITICAL,
-            retriable: false,
-            context: { module: "@google/genai", expectedExport: "GoogleGenAI" },
-        });
-    }
-    const Ctor = ctor;
-    return new Ctor({ apiKey });
-}

package/dist/providers/googleNativeGemini3/constants.d.ts

@@ -1 +0,0 @@
-export declare const GEMINI3_NATIVE_MAX_STEPS = 100;

package/dist/providers/googleNativeGemini3/constants.js

@@ -1 +0,0 @@
-export const GEMINI3_NATIVE_MAX_STEPS = 100;

package/dist/providers/huggingFace/utils.d.ts

@@ -1,2 +0,0 @@
-export declare const getHuggingFaceApiKey: () => string;
-export declare const getDefaultHuggingFaceModel: () => string;

package/dist/providers/huggingFace/utils.js

@@ -1,7 +0,0 @@
-import { createHuggingFaceConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const getHuggingFaceApiKey = () => {
-    return validateApiKey(createHuggingFaceConfig());
-};
-export const getDefaultHuggingFaceModel = () => {
-    return getProviderModel("HUGGINGFACE_MODEL", "microsoft/DialoGPT-medium");
-};

package/dist/providers/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * Provider exports for Vercel AI SDK integration
- * This file centralizes all AI provider classes for easy import and usage
- */
-export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex/index.js";
-export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock/index.js";
-export { AmazonSageMakerProvider as AmazonSageMaker } from "./amazonSagemaker.js";
-export { OpenAIProvider as OpenAI } from "./openAI/index.js";
-export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible/index.js";
-export { AnthropicProvider as AnthropicProvider } from "./anthropic/index.js";
-export { AzureOpenAIProvider } from "./azureOpenai.js";
-export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio/index.js";
-export { HuggingFaceProvider as HuggingFace } from "./huggingFace/index.js";
-export { OllamaProvider as Ollama } from "./ollama/index.js";
-export { MistralProvider as MistralAI } from "./mistral.js";
-export { LiteLLMProvider as LiteLLM } from "./litellm/index.js";
-export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
-export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim/index.js";
-export { LMStudioProvider as LMStudio } from "./lmStudio.js";
-export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";
-export { XaiProvider as Xai } from "./xai.js";
-export { GroqProvider as Groq } from "./groq.js";
-export { CohereProvider as Cohere } from "./cohere.js";
-export { TogetherAIProvider as TogetherAI } from "./togetherAi.js";
-export { FireworksProvider as Fireworks } from "./fireworks.js";
-export { PerplexityProvider as Perplexity } from "./perplexity.js";
-export { CloudflareProvider as Cloudflare } from "./cloudflare.js";
-export { VoyageProvider as Voyage } from "./voyage.js";
-export { JinaProvider as Jina } from "./jina.js";
-export { StabilityProvider as Stability } from "./stability.js";
-export { IdeogramProvider as Ideogram } from "./ideogram.js";
-export { RecraftProvider as Recraft } from "./recraft.js";
-export { ReplicateProvider as Replicate } from "./replicate.js";

package/dist/providers/index.js

@@ -1,33 +0,0 @@
-/**
- * Provider exports for Vercel AI SDK integration
- * This file centralizes all AI provider classes for easy import and usage
- */
-export { GoogleVertexProvider as GoogleVertexAI } from "./googleVertex/index.js";
-export { AmazonBedrockProvider as AmazonBedrock } from "./amazonBedrock/index.js";
-export { AmazonSageMakerProvider as AmazonSageMaker } from "./amazonSagemaker.js";
-export { OpenAIProvider as OpenAI } from "./openAI/index.js";
-export { OpenAICompatibleProvider as OpenAICompatible } from "./openaiCompatible/index.js";
-export { AnthropicProvider as AnthropicProvider } from "./anthropic/index.js";
-export { AzureOpenAIProvider } from "./azureOpenai.js";
-export { GoogleAIStudioProvider as GoogleAIStudio } from "./googleAiStudio/index.js";
-export { HuggingFaceProvider as HuggingFace } from "./huggingFace/index.js";
-export { OllamaProvider as Ollama } from "./ollama/index.js";
-export { MistralProvider as MistralAI } from "./mistral.js";
-export { LiteLLMProvider as LiteLLM } from "./litellm/index.js";
-export { DeepSeekProvider as DeepSeek } from "./deepseek.js";
-export { NvidiaNimProvider as NvidiaNim } from "./nvidiaNim/index.js";
-export { LMStudioProvider as LMStudio } from "./lmStudio.js";
-export { LlamaCppProvider as LlamaCpp } from "./llamaCpp.js";
-export { XaiProvider as Xai } from "./xai.js";
-export { GroqProvider as Groq } from "./groq.js";
-export { CohereProvider as Cohere } from "./cohere.js";
-export { TogetherAIProvider as TogetherAI } from "./togetherAi.js";
-export { FireworksProvider as Fireworks } from "./fireworks.js";
-export { PerplexityProvider as Perplexity } from "./perplexity.js";
-export { CloudflareProvider as Cloudflare } from "./cloudflare.js";
-export { VoyageProvider as Voyage } from "./voyage.js";
-export { JinaProvider as Jina } from "./jina.js";
-export { StabilityProvider as Stability } from "./stability.js";
-export { IdeogramProvider as Ideogram } from "./ideogram.js";
-export { RecraftProvider as Recraft } from "./recraft.js";
-export { ReplicateProvider as Replicate } from "./replicate.js";

package/dist/providers/litellm/constants.d.ts

@@ -1 +0,0 @@
-export declare const streamTracer: import("@opentelemetry/api").Tracer;

package/dist/providers/litellm/constants.js

@@ -1,2 +0,0 @@
-import { trace } from "@opentelemetry/api";
-export const streamTracer = trace.getTracer("neurolink.provider.litellm");

package/dist/providers/litellm/utils.d.ts

@@ -1,5 +0,0 @@
-export declare const getLiteLLMConfig: () => {
-    baseURL: string;
-    apiKey: string;
-};
-export declare const getDefaultLiteLLMModel: () => string;

package/dist/providers/litellm/utils.js

@@ -1,10 +0,0 @@
-import { getProviderModel } from "../../utils/providerConfig.js";
-export const getLiteLLMConfig = () => {
-    return {
-        baseURL: process.env.LITELLM_BASE_URL || "http://localhost:4000",
-        apiKey: process.env.LITELLM_API_KEY || "sk-anything",
-    };
-};
-export const getDefaultLiteLLMModel = () => {
-    return getProviderModel("LITELLM_MODEL", "openai/gpt-4o-mini");
-};

package/dist/providers/nvidiaNim/utils.d.ts

@@ -1,9 +0,0 @@
-import type { NvidiaNimExtraBody } from "../../types/index.js";
-export declare const makeLoggingFetch: (provider: string) => typeof fetch;
-export declare const envInt: (k: string) => number | undefined;
-export declare const envFloat: (k: string) => number | undefined;
-export declare const buildNvidiaNimExtraBody: (thinkingEnabled: boolean, maxTokens: number | undefined) => NvidiaNimExtraBody;
-export declare const stripReasoningBudget: (body: NvidiaNimExtraBody) => NvidiaNimExtraBody;
-export declare const stripChatTemplate: (body: NvidiaNimExtraBody) => NvidiaNimExtraBody;
-export declare const getNimApiKey: () => string;
-export declare const getDefaultNimModel: () => string;

package/dist/providers/nvidiaNim/utils.js

@@ -1,100 +0,0 @@
-import { NvidiaNimModels } from "../../constants/enums.js";
-import { createProxyFetch, maskProxyUrl } from "../../proxy/proxyFetch.js";
-import { logger } from "../../utils/logger.js";
-import { createNvidiaNimConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const makeLoggingFetch = (provider) => {
-    const base = createProxyFetch();
-    return (async (input, init) => {
-        const url = typeof input === "string"
-            ? input
-            : input instanceof URL
-                ? input.toString()
-                : input.url;
-        const reqSize = init?.body && typeof init.body === "string" ? init.body.length : 0;
-        const response = await base(input, init);
-        if (!response.ok) {
-            const safeUrl = maskProxyUrl(url) ?? "<redacted>";
-            if (process.env.NEUROLINK_DEBUG_HTTP === "1") {
-                const clone = response.clone();
-                const body = await clone.text().catch(() => "<unreadable>");
-                logger.warn(`[${provider}] upstream ${response.status}`, {
-                    url: safeUrl,
-                    body: body.slice(0, 800),
-                    reqSize,
-                });
-            }
-            else {
-                logger.warn(`[${provider}] upstream ${response.status} url=${safeUrl} reqSize=${reqSize}`);
-            }
-        }
-        return response;
-    });
-};
-export const envInt = (k) => {
-    const v = process.env[k];
-    if (!v) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(v, 10);
-    return Number.isFinite(parsed) ? parsed : undefined;
-};
-export const envFloat = (k) => {
-    const v = process.env[k];
-    if (!v) {
-        return undefined;
-    }
-    const parsed = Number.parseFloat(v);
-    return Number.isFinite(parsed) ? parsed : undefined;
-};
-export const buildNvidiaNimExtraBody = (thinkingEnabled, maxTokens) => {
-    const extra = {};
-    const topK = envInt("NVIDIA_NIM_TOP_K");
-    if (topK !== undefined && topK !== -1) {
-        extra.top_k = topK;
-    }
-    const minP = envFloat("NVIDIA_NIM_MIN_P");
-    if (minP !== undefined && minP !== 0) {
-        extra.min_p = minP;
-    }
-    const repPenalty = envFloat("NVIDIA_NIM_REPETITION_PENALTY");
-    if (repPenalty !== undefined && repPenalty !== 1) {
-        extra.repetition_penalty = repPenalty;
-    }
-    const minTokens = envInt("NVIDIA_NIM_MIN_TOKENS");
-    if (minTokens !== undefined && minTokens !== 0) {
-        extra.min_tokens = minTokens;
-    }
-    const chatTemplate = process.env.NVIDIA_NIM_CHAT_TEMPLATE;
-    if (chatTemplate) {
-        extra.chat_template = chatTemplate;
-    }
-    if (thinkingEnabled) {
-        extra.chat_template_kwargs = {
-            thinking: true,
-            enable_thinking: true,
-            ...(maxTokens ? { reasoning_budget: maxTokens } : {}),
-        };
-    }
-    return extra;
-};
-export const stripReasoningBudget = (body) => {
-    const cloned = { ...body };
-    if (cloned.chat_template_kwargs) {
-        const { reasoning_budget: _ignored, ...rest } = cloned.chat_template_kwargs;
-        cloned.chat_template_kwargs = rest;
-        if (Object.keys(cloned.chat_template_kwargs).length === 0) {
-            delete cloned.chat_template_kwargs;
-        }
-    }
-    return cloned;
-};
-export const stripChatTemplate = (body) => {
-    const { chat_template: _ignored, ...rest } = body;
-    return rest;
-};
-export const getNimApiKey = () => {
-    return validateApiKey(createNvidiaNimConfig());
-};
-export const getDefaultNimModel = () => {
-    return getProviderModel("NVIDIA_NIM_MODEL", NvidiaNimModels.LLAMA_3_3_70B_INSTRUCT);
-};

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

@@ -1,8 +0,0 @@
-import type { OllamaHttpError } from "../../types/index.js";
-export declare function isOllamaHttpError(error: unknown): error is OllamaHttpError;
-export declare function createOllamaHttpError(response: Response): Promise<OllamaHttpError>;
-export declare const getOllamaBaseUrl: () => string;
-export declare const isOpenAICompatibleMode: () => boolean;
-export declare const createAbortSignalWithTimeout: (timeoutMs: number) => AbortSignal;
-export declare const getDefaultOllamaModel: () => string;
-export declare const getOllamaTimeout: () => number;

package/dist/providers/ollama/utils.js

@@ -1,42 +0,0 @@
-import { ProviderError } from "../../types/index.js";
-import { DEFAULT_OLLAMA_MODEL } from "./constants.js";
-export function isOllamaHttpError(error) {
-    return (error instanceof ProviderError &&
-        typeof error.statusCode === "number" &&
-        typeof error.responseBody === "string");
-}
-export async function createOllamaHttpError(response) {
-    let responseBody = "";
-    try {
-        responseBody = (await response.text()).trim();
-    }
-    catch {
-        // Ignore unreadable bodies
-    }
-    const suffix = responseBody ? ` - ${responseBody.slice(0, 500)}` : "";
-    const error = new ProviderError(`Ollama API error: ${response.status} ${response.statusText}${suffix}`, "ollama");
-    error.statusCode = response.status;
-    error.statusText = response.statusText;
-    error.responseBody = responseBody;
-    return error;
-}
-export const getOllamaBaseUrl = () => {
-    return process.env.OLLAMA_BASE_URL || "http://localhost:11434";
-};
-export const isOpenAICompatibleMode = () => {
-    return process.env.OLLAMA_OPENAI_COMPATIBLE === "true";
-};
-export const createAbortSignalWithTimeout = (timeoutMs) => {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-    controller.signal.addEventListener("abort", () => {
-        clearTimeout(timeoutId);
-    });
-    return controller.signal;
-};
-export const getDefaultOllamaModel = () => {
-    return process.env.OLLAMA_MODEL || DEFAULT_OLLAMA_MODEL;
-};
-export const getOllamaTimeout = () => {
-    return parseInt(process.env.OLLAMA_TIMEOUT || "240000", 10);
-};

package/dist/providers/openAI/constants.d.ts

@@ -1 +0,0 @@
-export declare const streamTracer: import("@opentelemetry/api").Tracer;

package/dist/providers/openAI/constants.js

@@ -1,2 +0,0 @@
-import { trace } from "@opentelemetry/api";
-export const streamTracer = trace.getTracer("neurolink.provider.openai");

package/dist/providers/openAI/utils.d.ts

@@ -1,2 +0,0 @@
-export declare const getOpenAIApiKey: () => string;
-export declare const getOpenAIModel: () => string;

package/dist/providers/openAI/utils.js

@@ -1,7 +0,0 @@
-import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../../utils/providerConfig.js";
-export const getOpenAIApiKey = () => {
-    return validateApiKey(createOpenAIConfig());
-};
-export const getOpenAIModel = () => {
-    return getProviderModel("OPENAI_MODEL", "gpt-4o");
-};

package/dist/types/universalProviderOptions.d.ts

@@ -1,89 +0,0 @@
-/**
- * Universal Provider Options Interface (Phase 1: Factory Pattern)
- * Based on TypeScript factory pattern best practices for AI provider abstraction
- */
-import type { BaseContext, ContextConfig } from "./context.js";
-/**
- * Base configuration interface for all AI providers
- * Uses Parameter Object Pattern for flexible, extensible configuration
- */
-export type UniversalProviderOptions = {
-    prompt?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    systemPrompt?: string;
-    enableAnalytics?: boolean;
-    enableEvaluation?: boolean;
-    context?: BaseContext;
-    contextConfig?: Partial<ContextConfig>;
-    metadata?: Record<string, unknown>;
-    extensionOptions?: Record<string, unknown>;
-};
-/**
- * Generic provider options (without providerType)
- */
-export type GenericProviderOptions = Omit<UniversalProviderOptions, "providerType">;
-/**
- * Provider-specific configuration extensions
- * Discriminated union pattern for type-safe provider configs
- */
-export type OpenAIProviderOptions = UniversalProviderOptions & {
-    providerType: "openai";
-    organization?: string;
-    seed?: number;
-    topP?: number;
-};
-export type GoogleAIProviderOptions = UniversalProviderOptions & {
-    providerType: "google-ai";
-    topK?: number;
-    candidateCount?: number;
-    stopSequences?: string[];
-};
-export type AnthropicProviderOptions = UniversalProviderOptions & {
-    providerType: "anthropic";
-    topK?: number;
-    stopSequences?: string[];
-};
-export type BedrockProviderOptions = UniversalProviderOptions & {
-    providerType: "bedrock";
-    inferenceProfileArn?: string;
-    region?: string;
-};
-/**
- * Discriminated union for type-safe provider configuration
- * Enables compile-time type checking for provider-specific options
- */
-export type ProviderSpecificOptions = OpenAIProviderOptions | GoogleAIProviderOptions | AnthropicProviderOptions | BedrockProviderOptions;
-/**
- * Factory configuration interface
- * Supports both universal and provider-specific parameters
- */
-export type ProviderFactoryConfig = {
-    providerName: string;
-    modelName?: string;
-    options?: UniversalProviderOptions | ProviderSpecificOptions;
-    enableMCP?: boolean;
-};
-/**
- * Parameter normalization utilities
- * Converts between different parameter formats for backward compatibility
- */
-export declare class ParameterNormalizer {
-    /**
-     * Normalize legacy parameter formats to universal format
-     */
-    static normalizeToUniversal(optionsOrPrompt: UniversalProviderOptions | string): UniversalProviderOptions;
-    /**
-     * Retrieve the provider type if it exists, otherwise return null
-     */
-    private static getProviderType;
-    /**
-     * Extract provider-specific parameters safely
-     */
-    static extractProviderOptions<T extends ProviderSpecificOptions>(options: UniversalProviderOptions | ProviderSpecificOptions, providerType: T["providerType"]): T | GenericProviderOptions;
-    /**
-     * Merge default values with user-provided options
-     */
-    static mergeWithDefaults(options: UniversalProviderOptions, defaults: Partial<UniversalProviderOptions>): UniversalProviderOptions;
-}

package/dist/types/universalProviderOptions.js

@@ -1,54 +0,0 @@
-/**
- * Universal Provider Options Interface (Phase 1: Factory Pattern)
- * Based on TypeScript factory pattern best practices for AI provider abstraction
- */
-/**
- * Parameter normalization utilities
- * Converts between different parameter formats for backward compatibility
- */
-export class ParameterNormalizer {
-    /**
-     * Normalize legacy parameter formats to universal format
-     */
-    static normalizeToUniversal(optionsOrPrompt) {
-        if (typeof optionsOrPrompt === "string") {
-            return { prompt: optionsOrPrompt };
-        }
-        return optionsOrPrompt;
-    }
-    /**
-     * Retrieve the provider type if it exists, otherwise return null
-     */
-    static getProviderType(options) {
-        return "providerType" in options ? options.providerType : null;
-    }
-    /**
-     * Extract provider-specific parameters safely
-     */
-    static extractProviderOptions(options, providerType) {
-        const currentProviderType = ParameterNormalizer.getProviderType(options);
-        if (currentProviderType === providerType) {
-            return options;
-        }
-        // Handle case where options has providerType but doesn't match
-        if (currentProviderType !== null) {
-            const { providerType: _providerType, ...genericOptions } = options;
-            return genericOptions;
-        }
-        // Options don't have providerType, return as generic
-        return options;
-    }
-    /**
-     * Merge default values with user-provided options
-     */
-    static mergeWithDefaults(options, defaults) {
-        return {
-            ...defaults,
-            ...options,
-            // Merge nested objects (type-safe context merging)
-            context: { ...defaults.context, ...options.context },
-            contextConfig: { ...defaults.contextConfig, ...options.contextConfig },
-            metadata: { ...defaults.metadata, ...options.metadata },
-        };
-    }
-}