@juspay/neurolink 3.0.0 → 4.0.0

package/dist/providers/huggingFace.js

@@ -2,6 +2,8 @@ import { HfInference } from "@huggingface/inference";
 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 { evaluateResponse } from "../core/evaluation.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -107,7 +109,7 @@ class HuggingFaceLanguageModel {
                 inputs: prompt,
                 parameters: {
                     temperature: options.temperature || 0.7,
-                    max_new_tokens: options.maxTokens || 500,
+                    max_new_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
                     return_full_text: false,
                     do_sample: (options.temperature || 0.7) > 0,
                 },
@@ -229,7 +231,7 @@ export class HuggingFace {
             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`, {
@@ -332,12 +334,13 @@ export class HuggingFace {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "HuggingFace.generateText";
         const provider = "huggingface";
+        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`, {
@@ -379,6 +382,20 @@ export class HuggingFace {
                     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 {
@@ -407,4 +424,10 @@ export class HuggingFace {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

package/dist/providers/mcp-provider.d.ts

@@ -2,7 +2,7 @@
  * NeuroLink MCP-Aware AI Provider
  * Integrates MCP tools with AI providers following Lighthouse's pattern
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } from "ai";
 import type { ZodType, ZodTypeDef } from "zod";
 /**
@@ -51,6 +51,14 @@ export declare class MCPAwareProvider implements AIProvider {
      * Clean up session
      */
     cleanup(): Promise<void>;
+    /**
+     * 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 an MCP-aware provider

package/dist/providers/mcp-provider.js

@@ -192,6 +192,18 @@ Please provide a response based on this information.`;
             this.mcpInitialized = false;
         }
     }
+    /**
+     * 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 an MCP-aware provider

package/dist/providers/mistralAI.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 MistralAI implements AIProvider {
     private modelName;
     private client;
@@ -28,5 +28,7 @@ export declare class MistralAI 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>;
 }
 export default MistralAI;

package/dist/providers/mistralAI.js

@@ -2,6 +2,8 @@ import { createMistral } from "@ai-sdk/mistral";
 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 { evaluateResponse } from "../core/evaluation.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -89,7 +91,7 @@ export class MistralAI {
             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`, {
@@ -192,12 +194,13 @@ export class MistralAI {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "MistralAI.generateText";
         const provider = "mistral";
+        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`, {
@@ -239,6 +242,20 @@ export class MistralAI {
                     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 {
@@ -267,5 +284,11 @@ export class MistralAI {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }
 export default MistralAI;

package/dist/providers/ollama.d.ts

@@ -10,7 +10,7 @@
  * - Health checking and service validation
  * - Streaming and non-streaming text generation
  */
-import type { AIProvider, TextGenerationOptions, StreamTextOptions } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions, StreamTextOptions, EnhancedGenerateTextResult } from "../core/types.js";
 import type { GenerateTextResult, StreamTextResult, ToolSet } from "ai";
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
@@ -48,4 +48,6 @@ export declare class Ollama implements AIProvider {
      * Generate streaming text using Ollama local models
      */
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateTextResult | null>;
 }

package/dist/providers/ollama.js

@@ -13,6 +13,8 @@
 import { streamText, generateText, Output } from "ai";
 import { logger } from "../utils/logger.js";
 import { getDefaultTimeout, TimeoutError } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -106,7 +108,7 @@ class OllamaLanguageModel {
             stream: false,
             options: {
                 temperature: options.temperature || 0.7,
-                num_predict: options.maxTokens || 500,
+                num_predict: options.maxTokens ?? DEFAULT_MAX_TOKENS,
             },
         };
         const controller = new AbortController();
@@ -176,7 +178,7 @@ class OllamaLanguageModel {
             stream: true,
             options: {
                 temperature: options.temperature || 0.7,
-                num_predict: options.maxTokens || 500,
+                num_predict: options.maxTokens ?? DEFAULT_MAX_TOKENS,
             },
         };
         const controller = new AbortController();
@@ -391,12 +393,13 @@ export class Ollama {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "Ollama.generateText";
         const provider = "ollama";
+        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, } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             // Convert timeout to milliseconds if provided as string
@@ -437,6 +440,20 @@ export class Ollama {
                 finishReason: result.finishReason,
                 responseLength: result.text?.length || 0,
             });
+            // 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;
         }
         catch (err) {
@@ -461,7 +478,7 @@ export class Ollama {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
+            const { prompt, temperature = 0.7, maxTokens = DEFAULT_MAX_TOKENS, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             // Convert timeout to milliseconds if provided as string
@@ -542,4 +559,10 @@ export class Ollama {
             throw err; // Re-throw error to trigger fallback
         }
     }
+    async generate(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generateText(optionsOrPrompt, analysisSchema);
+    }
 }

package/dist/providers/openAI.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 OpenAI implements AIProvider {
     private modelName;
     private model;
@@ -11,4 +11,18 @@ export declare class OpenAI implements AIProvider {
     getModel(): LanguageModelV1;
     streamText(optionsOrPrompt: StreamTextOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamTextResult<ToolSet, unknown> | null>;
     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/providers/openAI.js

@@ -2,6 +2,9 @@ import { openai } from "@ai-sdk/openai";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, getDefaultTimeout, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { evaluateResponse } from "../core/evaluation.js";
+import { createAnalytics } from "../core/analytics.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -60,7 +63,7 @@ export class OpenAI {
             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 text started`, {
@@ -152,12 +155,13 @@ export class OpenAI {
     async generateText(optionsOrPrompt, analysisSchema) {
         const functionTag = "OpenAI.generateText";
         const provider = "openai";
+        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 text started`, {
@@ -198,6 +202,15 @@ export class OpenAI {
                     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 {
@@ -226,4 +239,22 @@ export class OpenAI {
             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/proxy/proxy-fetch.js

@@ -2,6 +2,7 @@
  * Proxy-aware fetch implementation for AI SDK providers
  * Implements the proven Vercel AI SDK proxy pattern using undici
  */
+import { logger } from "../utils/logger.js";
 /**
  * Create a proxy-aware fetch function
  * This implements the community-validated approach for Vercel AI SDK
@@ -11,12 +12,12 @@ export function createProxyFetch() {
     const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
     // If no proxy configured, return standard fetch
     if (!httpsProxy && !httpProxy) {
-        console.log("[Proxy Fetch] No proxy environment variables found - using standard fetch");
+        logger.debug("[Proxy Fetch] No proxy environment variables found - using standard fetch");
         return fetch;
     }
-    console.log(`[Proxy Fetch] Configuring proxy with undici ProxyAgent:`);
-    console.log(`[Proxy Fetch] HTTP_PROXY: ${httpProxy || "not set"}`);
-    console.log(`[Proxy Fetch] HTTPS_PROXY: ${httpsProxy || "not set"}`);
+    logger.debug(`[Proxy Fetch] Configuring proxy with undici ProxyAgent`);
+    logger.debug(`[Proxy Fetch] HTTP_PROXY: ${httpProxy || "not set"}`);
+    logger.debug(`[Proxy Fetch] HTTPS_PROXY: ${httpsProxy || "not set"}`);
     // Return proxy-aware fetch function
     return async (input, init) => {
         try {
@@ -30,7 +31,7 @@ export function createProxyFetch() {
                     : new URL(input.url);
             const proxyUrl = url.protocol === "https:" ? httpsProxy : httpProxy;
             if (proxyUrl) {
-                console.log(`[Proxy Fetch] Creating ProxyAgent for ${url.hostname} via ${proxyUrl}`);
+                logger.debug(`[Proxy Fetch] Creating ProxyAgent for ${url.hostname} via ${proxyUrl}`);
                 // Create ProxyAgent
                 const dispatcher = new ProxyAgent(proxyUrl);
                 // Use undici fetch with dispatcher
@@ -38,12 +39,12 @@ export function createProxyFetch() {
                     ...init,
                     dispatcher: dispatcher,
                 });
-                console.log(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
+                logger.debug(`[Proxy Fetch] ✅ Request proxied successfully to ${url.hostname}`);
                 return response; // Type assertion to avoid complex type issues
             }
         }
         catch (error) {
-            console.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
+            logger.warn(`[Proxy Fetch] Proxy failed (${error.message}), falling back to direct connection`);
         }
         // Fallback to standard fetch
         return fetch(input, init);

package/dist/services/streaming/streaming-manager.d.ts

@@ -0,0 +1,29 @@
+import { EventEmitter } from "events";
+import type { StreamingSession, StreamingConfig, StreamingPoolConfig, StreamingMetrics, StreamingHealthStatus, BufferConfig } from "../types.js";
+export declare class StreamingManager extends EventEmitter {
+    private activeSessions;
+    private streamingPools;
+    private metrics;
+    private healthCheckInterval?;
+    private startTime;
+    constructor();
+    createStreamingSession(config: StreamingConfig): Promise<StreamingSession>;
+    terminateStreamingSession(sessionId: string): Promise<void>;
+    pauseStreamingSession(sessionId: string): Promise<void>;
+    resumeStreamingSession(sessionId: string): Promise<void>;
+    optimizeStreamingLatency(sessionId: string): Promise<void>;
+    enableStreamingCompression(sessionId: string): Promise<void>;
+    configureStreamingBuffering(sessionId: string, bufferConfig: BufferConfig): Promise<void>;
+    createStreamingPool(poolId: string, config: StreamingPoolConfig): Promise<void>;
+    balanceStreamingLoad(poolId: string): Promise<void>;
+    scaleStreamingCapacity(poolId: string, scale: number): Promise<void>;
+    getStreamingMetrics(sessionId?: string): StreamingMetrics;
+    getStreamingHealthStatus(): StreamingHealthStatus;
+    private updateGlobalMetrics;
+    private startHealthMonitoring;
+    private roundRobinBalance;
+    private leastConnectionsBalance;
+    private weightedBalance;
+    private adaptiveBalance;
+    destroy(): void;
+}