@juspay/neurolink 3.0.0 → 4.0.0

package/dist/lib/providers/analytics-helper.js

@@ -0,0 +1,151 @@
+/**
+ * Enhanced Analytics Helper for All Providers
+ * Ensures consistent analytics data format across providers
+ * Integrates with Universal Evaluation System
+ */
+/**
+ * Create standardized analytics data from provider response
+ */
+export function createAnalytics(provider, model, result, responseTime, context) {
+    // Handle different token usage formats across providers
+    const tokenUsage = result.usage || {};
+    // Standardize token field names across providers
+    const inputTokens = tokenUsage.promptTokens ||
+        tokenUsage.input_tokens ||
+        tokenUsage.inputTokens ||
+        0;
+    const outputTokens = tokenUsage.completionTokens ||
+        tokenUsage.output_tokens ||
+        tokenUsage.outputTokens ||
+        0;
+    const totalTokens = tokenUsage.totalTokens ||
+        tokenUsage.total_tokens ||
+        inputTokens + outputTokens ||
+        0;
+    // Simple cost estimation for synchronous use
+    const estimatedCost = totalTokens > 0 ? totalTokens * 0.00001 : 0;
+    return {
+        provider,
+        model,
+        tokens: {
+            input: inputTokens,
+            output: outputTokens,
+            total: totalTokens,
+        },
+        cost: estimatedCost,
+        responseTime,
+        timestamp: new Date().toISOString(),
+        context,
+    };
+}
+/**
+ * Create enhanced analytics data with accurate cost calculations (async version)
+ */
+export async function createEnhancedAnalytics(provider, model, result, responseTime, context) {
+    // Handle different token usage formats across providers
+    const tokenUsage = result.usage || {};
+    // Standardize token field names across providers
+    const inputTokens = tokenUsage.promptTokens ||
+        tokenUsage.input_tokens ||
+        tokenUsage.inputTokens ||
+        0;
+    const outputTokens = tokenUsage.completionTokens ||
+        tokenUsage.output_tokens ||
+        tokenUsage.outputTokens ||
+        0;
+    const totalTokens = tokenUsage.totalTokens ||
+        tokenUsage.total_tokens ||
+        inputTokens + outputTokens ||
+        0;
+    // Enhanced cost calculation using provider configuration
+    const { costDetails, estimatedCost } = await calculateEnhancedCost(provider, inputTokens, outputTokens);
+    return {
+        provider,
+        model,
+        tokens: {
+            input: inputTokens,
+            output: outputTokens,
+            total: totalTokens,
+        },
+        cost: estimatedCost,
+        responseTime,
+        timestamp: new Date().toISOString(),
+        context,
+        costDetails,
+    };
+}
+/**
+ * Calculate enhanced cost details using provider configurations
+ */
+export async function calculateEnhancedCost(provider, inputTokens, outputTokens) {
+    try {
+        // Import provider configuration dynamically
+        const { getProviderConfig } = await import("../core/evaluation-providers.js");
+        const providerConfig = getProviderConfig(provider);
+        if (!providerConfig?.costPerToken) {
+            // Fallback to rough estimation
+            const estimatedCost = (inputTokens + outputTokens) * 0.00001;
+            return {
+                costDetails: {
+                    inputCost: inputTokens * 0.00001,
+                    outputCost: outputTokens * 0.00001,
+                    totalCost: estimatedCost,
+                    currency: "USD",
+                },
+                estimatedCost,
+            };
+        }
+        // Use accurate provider costs
+        const inputCost = inputTokens * providerConfig.costPerToken.input;
+        const outputCost = outputTokens * providerConfig.costPerToken.output;
+        const totalCost = inputCost + outputCost;
+        return {
+            costDetails: {
+                inputCost,
+                outputCost,
+                totalCost,
+                currency: "USD",
+            },
+            estimatedCost: totalCost,
+        };
+    }
+    catch (error) {
+        // Fallback on error
+        const estimatedCost = (inputTokens + outputTokens) * 0.00001;
+        return {
+            costDetails: {
+                inputCost: inputTokens * 0.00001,
+                outputCost: outputTokens * 0.00001,
+                totalCost: estimatedCost,
+                currency: "USD",
+            },
+            estimatedCost,
+        };
+    }
+}
+/**
+ * Enhance analytics with evaluation data
+ */
+export function enhanceAnalyticsWithEvaluation(analytics, evaluationResult) {
+    return {
+        ...analytics,
+        evaluation: {
+            relevanceScore: evaluationResult.relevanceScore || 0,
+            accuracyScore: evaluationResult.accuracyScore || 0,
+            completenessScore: evaluationResult.completenessScore || 0,
+            overall: evaluationResult.overall || 0,
+            evaluationProvider: evaluationResult.evaluationProvider,
+            evaluationTime: evaluationResult.evaluationTime,
+            evaluationAttempt: evaluationResult.evaluationAttempt,
+        },
+        // Add evaluation cost if available
+        costDetails: analytics.costDetails
+            ? {
+                ...analytics.costDetails,
+                evaluationCost: evaluationResult.evaluationConfig?.costEstimate || 0,
+                totalCost: (analytics.costDetails.totalCost || 0) +
+                    (evaluationResult.evaluationConfig?.costEstimate || 0),
+            }
+            : undefined,
+    };
+}

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

@@ -4,7 +4,9 @@
  * Direct integration with Anthropic's Claude models via their native API.
  * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Schema } from "ai";
 import { AIProviderName } from "../core/types.js";
 export declare class AnthropicProvider implements AIProvider {
     readonly name: AIProviderName;
@@ -31,4 +33,12 @@ export declare class AnthropicProvider implements AIProvider {
     supportsStreaming(): boolean;
     supportsSchema(): boolean;
     getCapabilities(): string[];
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/lib/providers/anthropic.js

@@ -7,6 +7,9 @@
 import { AIProviderName } from "../core/types.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
+import { createAnalytics } from "../core/analytics.js";
 import { createProxyFetch } from "../proxy/proxy-fetch.js";
 export class AnthropicProvider {
     name = AIProviderName.ANTHROPIC;
@@ -58,12 +61,13 @@ export class AnthropicProvider {
     async generateText(optionsOrPrompt, schema) {
         const functionTag = "AnthropicProvider.generateText";
         const provider = "anthropic";
+        const startTime = Date.now();
         logger.debug(`[${functionTag}] Starting text generation`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "generate"), } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "generate"), enableAnalytics = false, enableEvaluation = false, context, } = options;
         logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
         const requestBody = {
             model: this.getModel(),
@@ -86,7 +90,7 @@ export class AnthropicProvider {
             timeoutController?.cleanup();
             logger.debug(`[${functionTag}] Success. Generated ${data.usage.output_tokens} tokens`);
             const content = data.content.map((block) => block.text).join("");
-            return {
+            const result = {
                 content,
                 provider: this.name,
                 model: data.model,
@@ -97,6 +101,15 @@ export class AnthropicProvider {
                 },
                 finishReason: data.stop_reason,
             };
+            // Add analytics if enabled
+            if (options.enableAnalytics) {
+                result.analytics = createAnalytics(provider, this.defaultModel, result, Date.now() - startTime, options.context);
+            }
+            // Add evaluation if enabled
+            if (options.enableEvaluation) {
+                result.evaluation = await evaluateResponse(prompt, result.content, options.context);
+            }
+            return result;
         }
         catch (error) {
             // Always cleanup timeout
@@ -133,7 +146,7 @@ export class AnthropicProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "stream"), } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", timeout = getDefaultTimeout(provider, "stream"), } = options;
         logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
         const requestBody = {
             model: this.getModel(),
@@ -243,7 +256,7 @@ export class AnthropicProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.", } = options;
         logger.debug(`[AnthropicProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const requestBody = {
             model: this.getModel(),
@@ -377,4 +390,16 @@ export class AnthropicProvider {
             "long-context", // Claude models support up to 200k tokens
         ];
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

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

@@ -4,7 +4,7 @@
  * Enterprise-grade OpenAI integration through Microsoft Azure.
  * Supports all OpenAI models with enhanced security and compliance.
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 import { AIProviderName } from "../core/types.js";
 export declare class AzureOpenAIProvider implements AIProvider {
     readonly name: AIProviderName;
@@ -34,4 +34,6 @@ export declare class AzureOpenAIProvider implements AIProvider {
     supportsStreaming(): boolean;
     supportsSchema(): boolean;
     getCapabilities(): string[];
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/lib/providers/azureOpenAI.js

@@ -7,6 +7,8 @@
 import { AIProviderName } from "../core/types.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
 export class AzureOpenAIProvider {
     name = AIProviderName.AZURE;
     apiKey;
@@ -69,12 +71,13 @@ export class AzureOpenAIProvider {
     async generateText(optionsOrPrompt, schema) {
         const functionTag = "AzureOpenAIProvider.generateText";
         const provider = "azure";
+        const startTime = Date.now();
         logger.debug(`[${functionTag}] Starting text generation`);
         // Parse parameters with backward compatibility
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, "generate"), } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, "generate"), } = options;
         logger.debug(`[${functionTag}] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}, Timeout: ${timeout}`);
         const messages = [];
         if (systemPrompt) {
@@ -101,7 +104,7 @@ export class AzureOpenAIProvider {
             timeoutController?.cleanup();
             logger.debug(`[${functionTag}] Success. Generated ${data.usage.completion_tokens} tokens`);
             const content = data.choices[0]?.message?.content || "";
-            return {
+            const result = {
                 content,
                 provider: this.name,
                 model: data.model,
@@ -112,6 +115,21 @@ export class AzureOpenAIProvider {
                 },
                 finishReason: data.choices[0]?.finish_reason || "stop",
             };
+            // Add analytics if enabled
+            if (options.enableAnalytics) {
+                result.analytics = {
+                    provider: this.name,
+                    model: data.model,
+                    tokens: result.usage,
+                    responseTime: Date.now() - startTime,
+                    context: options.context,
+                };
+            }
+            // Add evaluation if enabled
+            if (options.enableEvaluation) {
+                result.evaluation = await evaluateResponse(options.prompt, content, options.context);
+            }
+            return result;
         }
         catch (error) {
             // Always cleanup timeout
@@ -148,7 +166,7 @@ export class AzureOpenAIProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, "stream"), } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are a helpful AI assistant.", timeout = getDefaultTimeout(provider, "stream"), } = options;
         logger.debug(`[${functionTag}] Streaming prompt: "${prompt.substring(0, 100)}...", Timeout: ${timeout}`);
         const messages = [];
         if (systemPrompt) {
@@ -262,7 +280,7 @@ export class AzureOpenAIProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = "You are a helpful AI assistant.", } = options;
+        const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = "You are a helpful AI assistant.", } = options;
         logger.debug(`[AzureOpenAIProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const messages = [];
         if (systemPrompt) {
@@ -409,4 +427,10 @@ export class AzureOpenAIProvider {
             "content-filtering",
         ];
     }
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

package/dist/lib/providers/function-calling-provider.d.ts

@@ -3,7 +3,7 @@
  * Integrates MCP tools directly with AI SDK's function calling capabilities
  * This is the missing piece that enables true AI function calling!
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 import { type GenerateTextResult, type StreamTextResult, type ToolSet, type Schema } from "ai";
 import type { ZodType, ZodTypeDef } from "zod";
 /**
@@ -48,6 +48,14 @@ export declare class FunctionCallingProvider implements AIProvider {
      * Stream text with function calling support
      */
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
 }
 /**
  * Create a function-calling enhanced version of any AI provider

package/dist/lib/providers/function-calling-provider.js

@@ -7,6 +7,7 @@ import { generateText as aiGenerateText, Output, } from "ai";
 import { getAvailableFunctionTools, executeFunctionCall, isFunctionCallingAvailable, } from "../mcp/function-calling.js";
 import { createExecutionContext } from "../mcp/context-manager.js";
 import { mcpLogger } from "../mcp/logging.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 /**
  * Enhanced provider that enables real function calling with MCP tools
  */
@@ -106,7 +107,7 @@ export class FunctionCallingProvider {
                 prompt: options.prompt,
                 system: options.systemPrompt || "You are a helpful AI assistant.",
                 temperature: options.temperature || 0.7,
-                maxTokens: options.maxTokens || 500,
+                maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
                 tools: toolsWithExecution,
                 toolChoice: "auto", // Let the AI decide when to use tools
                 maxSteps: 5, // CRITICAL: Enable multi-turn tool execution
@@ -337,6 +338,18 @@ These functions provide accurate, real-time data. Use them actively to enhance y
             return this.baseProvider.streamText(options, analysisSchema);
         }
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }
 /**
  * Create a function-calling enhanced version of any AI provider

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

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult, type LanguageModelV1 } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 export declare class GoogleAIStudio implements AIProvider {
     private modelName;
     /**
@@ -32,4 +32,18 @@ export declare class GoogleAIStudio implements AIProvider {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/lib/providers/googleAIStudio.js

@@ -2,7 +2,9 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxy-fetch.js";
+import { evaluateResponse } from "../core/evaluation.js";
 // CRITICAL: Setup environment variables early for AI SDK compatibility
 // The AI SDK specifically looks for GOOGLE_GENERATIVE_AI_API_KEY
 // We need to ensure this is set before any AI SDK operations
@@ -113,7 +115,7 @@ export class GoogleAIStudio {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "stream"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -219,12 +221,13 @@ export class GoogleAIStudio {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "GoogleAIStudio.generateText";
         const provider = "google-ai";
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "generate"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, tools, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate request started`, {
@@ -272,6 +275,15 @@ export class GoogleAIStudio {
                     responseLength: result.text?.length || 0,
                     timeout,
                 });
+                // Add analytics if enabled
+                if (options.enableAnalytics) {
+                    const { createAnalytics } = await import("./analytics-helper.js");
+                    result.analytics = createAnalytics(provider, this.modelName, result, Date.now() - startTime, options.context);
+                }
+                // Add evaluation if enabled
+                if (options.enableEvaluation) {
+                    result.evaluation = await evaluateResponse(prompt, result.text, options.context, options.evaluationDomain, options.toolUsageContext, options.conversationHistory);
+                }
                 return result;
             }
             finally {
@@ -300,4 +312,22 @@ export class GoogleAIStudio {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     * @param optionsOrPrompt - TextGenerationOptions object or prompt string
+     * @param analysisSchema - Optional schema for output validation
+     * @returns Promise resolving to GenerateTextResult or null
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

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

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 export declare class GoogleVertexAI implements AIProvider {
     private modelName;
     /**
@@ -27,4 +27,12 @@ export declare class GoogleVertexAI implements AIProvider {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/lib/providers/googleVertexAI.js

@@ -24,7 +24,9 @@ async function getCreateVertexAnthropic() {
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxy-fetch.js";
+import { evaluateResponse } from "../core/evaluation.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -289,7 +291,7 @@ export class GoogleVertexAI {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -392,12 +394,13 @@ export class GoogleVertexAI {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "GoogleVertexAI.generateText";
         const provider = "vertex";
+        const startTime = Date.now();
         try {
             // Parse parameters - support both string and options object
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate request started`, {
@@ -440,6 +443,20 @@ export class GoogleVertexAI {
                     responseLength: result.text?.length || 0,
                     timeout,
                 });
+                // Add analytics if enabled
+                if (options.enableAnalytics) {
+                    result.analytics = {
+                        provider,
+                        model: this.modelName,
+                        tokens: result.usage,
+                        responseTime: Date.now() - startTime,
+                        context: options.context,
+                    };
+                }
+                // Add evaluation if enabled
+                if (options.enableEvaluation) {
+                    result.evaluation = await evaluateResponse(prompt, result.text, options.context);
+                }
                 return result;
             }
             finally {
@@ -469,4 +486,16 @@ export class GoogleVertexAI {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    /**
+     * Alias for generateText() - CLI-SDK consistency
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    /**
+     * Short alias for generateText() - CLI-SDK consistency
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

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

@@ -1,6 +1,6 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import { type StreamTextResult, type ToolSet, type Schema, type GenerateTextResult } from "ai";
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 export declare class HuggingFace implements AIProvider {
     private modelName;
     private client;
@@ -28,4 +28,6 @@ export declare class HuggingFace implements AIProvider {
      * @returns Promise resolving to GenerateTextResult or null if operation fails
      */
     generateText(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateTextResult<ToolSet, unknown> | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
 }