@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/telemetry/attributes.js

@@ -1,100 +0,0 @@
-export const ATTR = {
-    // GenAI standard (OpenTelemetry semantic conventions)
-    GEN_AI_SYSTEM: "gen_ai.system",
-    GEN_AI_MODEL: "gen_ai.request.model",
-    GEN_AI_OPERATION: "gen_ai.operation.name",
-    GEN_AI_INPUT_TOKENS: "gen_ai.usage.input_tokens",
-    GEN_AI_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
-    GEN_AI_FINISH_REASON: "gen_ai.response.finish_reason",
-    GEN_AI_COST_USD: "gen_ai.cost_usd",
-    GEN_AI_TOOL_NAME: "gen_ai.tool.name",
-    GEN_AI_TEMPERATURE: "gen_ai.request.temperature",
-    GEN_AI_MAX_TOKENS: "gen_ai.request.max_tokens",
-    // NeuroLink custom
-    NL_PROVIDER: "neurolink.provider",
-    NL_MODEL: "neurolink.model",
-    NL_STREAM_MODE: "neurolink.stream_mode",
-    NL_TOOL_COUNT: "neurolink.tool_count",
-    NL_MESSAGE_COUNT: "neurolink.message_count",
-    NL_HAS_TOOLS: "neurolink.has_tools",
-    NL_INPUT_LENGTH: "neurolink.input_length",
-    NL_OUTPUT_LENGTH: "neurolink.output_length",
-    NL_REQUEST_ID: "neurolink.request_id",
-    NL_PATH: "neurolink.path",
-    NL_HAS_MEMORY: "neurolink.has_conversation_memory",
-    NL_COST: "neurolink.cost",
-    NL_STRUCTURED_OUTPUT: "neurolink.structured_output",
-    NL_HAS_FALLBACK: "neurolink.has_fallback",
-    // MCP
-    MCP_SERVER_ID: "mcp.server_id",
-    MCP_TOOL_NAME: "mcp.tool_name",
-    MCP_TIMEOUT_MS: "mcp.timeout_ms",
-    MCP_TRANSPORT: "mcp.transport",
-    MCP_CIRCUIT_STATE: "mcp.circuit_state",
-    // Session/Memory
-    SESSION_ID: "session.id",
-    USER_ID: "user.id",
-    MEMORY_TYPE: "memory.type",
-    MESSAGE_COUNT: "message.count",
-    CONTENT_LENGTH: "content.length",
-    // RAG
-    RAG_FILE_COUNT: "rag.file_count",
-    RAG_STRATEGY: "rag.strategy",
-    RAG_CHUNK_SIZE: "rag.chunk_size",
-    RAG_TOP_K: "rag.top_k",
-    RAG_RESULT_COUNT: "rag.result_count",
-    // Message building
-    MSG_COUNT: "message.build.count",
-    MSG_HAS_IMAGES: "message.has_images",
-    MSG_HAS_FILES: "message.has_files",
-    MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt",
-    MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length",
-    MSG_IS_MULTIMODAL: "message.is_multimodal",
-    // File processing
-    FILE_NAME: "file.name",
-    FILE_MIMETYPE: "file.mimetype",
-    FILE_SIZE_BYTES: "file.size_bytes",
-    FILE_CATEGORY: "file.category",
-    FILE_OUTPUT_LENGTH: "file.output_length",
-    FILE_SUCCESS: "file.success",
-    FILE_PROCESSOR_USED: "file.processor_used",
-    FILE_CONFIDENCE: "file.detection_confidence",
-    FILE_HAS_IMAGES: "file.has_images",
-    FILE_IMAGE_COUNT: "file.image_count",
-    FILE_ERROR: "file.error",
-    FILE_SKIPPED_REASON: "file.skipped_reason",
-    FILE_TOTAL_COUNT: "file.total_count",
-    FILE_INCLUDED_COUNT: "file.included_count",
-    FILE_CONTENT_TYPE: "file.content_type",
-    // Video processing
-    VIDEO_DURATION_SEC: "video.duration_sec",
-    VIDEO_WIDTH: "video.width",
-    VIDEO_HEIGHT: "video.height",
-    VIDEO_CODEC: "video.codec",
-    VIDEO_AUDIO_CODEC: "video.audio_codec",
-    VIDEO_FORMAT: "video.format",
-    VIDEO_BITRATE: "video.bitrate",
-    VIDEO_KEYFRAMES_EXTRACTED: "video.keyframes_extracted",
-    VIDEO_TARGET_FRAMES: "video.target_frames",
-    VIDEO_INTERVAL_SEC: "video.interval_sec",
-    VIDEO_FRAME_QUALITY: "video.frame_quality",
-    VIDEO_FRAME_RESIZE_PX: "video.frame_resize_px",
-    VIDEO_FRAMES_RESIZED: "video.frames_resized",
-    VIDEO_TOTAL_FRAME_BYTES: "video.total_frame_bytes",
-    VIDEO_HAS_SUBTITLES: "video.has_subtitles",
-    VIDEO_SUBTITLE_LENGTH: "video.subtitle_length",
-    VIDEO_TEXT_CONTENT_LENGTH: "video.text_content_length",
-    VIDEO_HAS_METADATA: "video.has_metadata",
-    VIDEO_HAS_KEYFRAMES: "video.has_keyframes",
-    VIDEO_TEMP_PATH: "video.temp_path",
-    VIDEO_BYTES_WRITTEN: "video.bytes_written",
-    VIDEO_WRITE_DURATION_MS: "video.write_duration_ms",
-    VIDEO_STEP: "video.step",
-    // Context
-    CONTEXT_STAGE: "context.compaction_stage",
-    CONTEXT_TOKENS_BEFORE: "context.tokens_before",
-    CONTEXT_TOKENS_AFTER: "context.tokens_after",
-    // Middleware
-    MW_COUNT: "middleware.count",
-    MW_NAMES: "middleware.names",
-};

package/dist/client/telemetry/index.js

@@ -1,26 +0,0 @@
-// Optional Telemetry Infrastructure (Phase 2)
-export { TelemetryService } from "./telemetryService.js";
-export { tracers } from "./tracers.js";
-export { withSpan, withClientSpan } from "./withSpan.js";
-export { ATTR } from "./attributes.js";
-import { logger } from "../utils/logger.js";
-/**
- * Initialize telemetry for NeuroLink
- * OPTIONAL - Only works when NEUROLINK_TELEMETRY_ENABLED=true
- */
-export async function initializeTelemetry() {
-    const { TelemetryService } = await import("./telemetryService.js");
-    const telemetry = TelemetryService.getInstance();
-    if (telemetry.isEnabled()) {
-        await telemetry.initialize();
-        logger.info("[NeuroLink] Telemetry initialized");
-    }
-    return telemetry;
-}
-/**
- * Get telemetry status
- */
-export async function getTelemetryStatus() {
-    const { TelemetryService } = await import("./telemetryService.js");
-    return TelemetryService.getInstance().getStatus();
-}

package/dist/client/telemetry/telemetryService.js

@@ -1,308 +0,0 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { metrics, trace, } from "@opentelemetry/api";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
-import { logger } from "../utils/logger.js";
-export class TelemetryService {
-    static instance;
-    sdk;
-    enabled = false;
-    initialized = false;
-    meter;
-    tracer;
-    // Optional Metrics (only created when enabled)
-    aiRequestCounter;
-    aiRequestDuration;
-    aiTokensUsed;
-    aiProviderErrors;
-    aiCostUsd;
-    mcpToolCalls;
-    connectionCounter;
-    responseTimeHistogram;
-    // Runtime metrics tracking
-    activeConnectionCount = 0;
-    errorCount = 0;
-    requestCount = 0;
-    totalResponseTime = 0;
-    responseTimeCount = 0;
-    constructor() {
-        // Check if telemetry is enabled
-        this.enabled = this.isTelemetryEnabled();
-        if (this.enabled) {
-            this.initializeTelemetry();
-        }
-        else {
-            logger.debug("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
-        }
-    }
-    static getInstance() {
-        if (!TelemetryService.instance) {
-            TelemetryService.instance = new TelemetryService();
-        }
-        return TelemetryService.instance;
-    }
-    isTelemetryEnabled() {
-        return (process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
-            process.env.OTEL_EXPORTER_OTLP_ENDPOINT !== undefined);
-    }
-    initializeTelemetry() {
-        try {
-            const resource = resourceFromAttributes({
-                [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
-                [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
-            });
-            this.sdk = new NodeSDK({
-                resource,
-                // Note: Metric reader configured separately
-                instrumentations: [getNodeAutoInstrumentations()],
-            });
-            this.meter = metrics.getMeter("neurolink-ai");
-            this.tracer = trace.getTracer("neurolink-ai");
-            this.initializeMetrics();
-            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
-        }
-        catch (error) {
-            logger.error("[Telemetry] Failed to initialize:", error);
-            this.enabled = false;
-        }
-    }
-    initializeMetrics() {
-        if (!this.enabled || !this.meter) {
-            return;
-        }
-        this.aiRequestCounter = this.meter.createCounter("ai_requests_total", {
-            description: "Total number of AI requests",
-        });
-        this.aiRequestDuration = this.meter.createHistogram("ai_request_duration_ms", {
-            description: "AI request duration in milliseconds",
-        });
-        this.aiTokensUsed = this.meter.createCounter("ai_tokens_used_total", {
-            description: "Total number of AI tokens used",
-        });
-        this.aiCostUsd = this.meter.createCounter("ai_cost_usd_total", {
-            description: "Total accumulated AI cost in USD",
-        });
-        this.aiProviderErrors = this.meter.createCounter("ai_provider_errors_total", {
-            description: "Total number of AI provider errors",
-        });
-        this.mcpToolCalls = this.meter.createCounter("mcp_tool_calls_total", {
-            description: "Total number of MCP tool calls",
-        });
-        this.connectionCounter = this.meter.createCounter("connections_total", {
-            description: "Total number of connections",
-        });
-        this.responseTimeHistogram = this.meter.createHistogram("response_time_ms", {
-            description: "Response time in milliseconds",
-        });
-    }
-    async initialize() {
-        if (!this.enabled) {
-            return;
-        }
-        try {
-            await this.sdk?.start();
-            this.initialized = true;
-            logger.debug("[Telemetry] SDK started successfully");
-        }
-        catch (error) {
-            logger.error("[Telemetry] Failed to start SDK:", error);
-            this.enabled = false;
-            this.initialized = false;
-        }
-    }
-    // AI Operation Tracing (NO-OP when disabled)
-    /**
-     * @deprecated Vercel AI SDK's experimental_telemetry creates ai.generateText/ai.streamText
-     * spans automatically via OpenTelemetry. Using this method would create duplicate spans.
-     * Kept for potential future use with non-Vercel providers (e.g., Amazon Bedrock).
-     * See: TelemetryHandler.getTelemetryConfig() for the active telemetry path.
-     */
-    async traceAIRequest(provider, operation, operationType = "generate_text") {
-        if (!this.enabled || !this.tracer) {
-            return await operation();
-        }
-        const span = this.tracer.startSpan(`ai.${provider}.${operationType}`, {
-            attributes: {
-                "ai.provider": provider,
-                "ai.operation": operationType,
-            },
-        });
-        try {
-            const result = await operation();
-            span.setStatus({ code: 1 }); // OK
-            return result;
-        }
-        catch (error) {
-            span.setStatus({
-                code: 2,
-                message: error instanceof Error ? error.message : "Unknown error",
-            }); // ERROR
-            span.recordException(error);
-            throw error;
-        }
-        finally {
-            span.end();
-        }
-    }
-    // Metrics Recording (NO-OP when disabled)
-    recordAIRequest(provider, model, tokens, duration, cost) {
-        // Track runtime metrics
-        this.requestCount++;
-        this.totalResponseTime += duration;
-        this.responseTimeCount++;
-        if (!this.enabled || !this.aiRequestCounter) {
-            return;
-        }
-        const labels = { provider, model };
-        this.aiRequestCounter.add(1, labels);
-        this.aiRequestDuration?.record(duration, labels);
-        this.aiTokensUsed?.add(tokens, labels);
-        if (cost !== undefined && Number.isFinite(cost) && cost > 0) {
-            this.aiCostUsd?.add(cost, labels);
-        }
-    }
-    recordAIError(provider, error) {
-        // Track runtime metrics
-        this.errorCount++;
-        if (!this.enabled || !this.aiProviderErrors) {
-            return;
-        }
-        this.aiProviderErrors.add(1, {
-            provider,
-            error: error.name,
-            message: error.message.substring(0, 100), // Limit message length
-        });
-    }
-    recordMCPToolCall(toolName, duration, success) {
-        if (!this.enabled || !this.mcpToolCalls) {
-            return;
-        }
-        this.mcpToolCalls.add(1, {
-            tool: toolName,
-            success: success.toString(),
-            duration_bucket: this.getDurationBucket(duration),
-        });
-    }
-    recordConnection(type) {
-        // Track runtime metrics
-        this.activeConnectionCount++;
-        if (!this.enabled || !this.connectionCounter) {
-            return;
-        }
-        this.connectionCounter.add(1, { connection_type: type });
-    }
-    recordConnectionClosed(type) {
-        // Track runtime metrics
-        this.activeConnectionCount = Math.max(0, this.activeConnectionCount - 1);
-        if (!this.enabled || !this.connectionCounter) {
-            return;
-        }
-        // Optionally record disconnection metrics if needed
-        this.connectionCounter.add(-1, {
-            connection_type: type,
-            event: "disconnect",
-        });
-    }
-    recordResponseTime(endpoint, method, duration) {
-        // Track runtime metrics
-        this.totalResponseTime += duration;
-        this.responseTimeCount++;
-        if (!this.enabled || !this.responseTimeHistogram) {
-            return;
-        }
-        this.responseTimeHistogram.record(duration, {
-            endpoint,
-            method,
-            status_bucket: this.getStatusBucket(duration),
-        });
-    }
-    // Custom Metrics
-    recordCustomMetric(name, value, labels) {
-        if (!this.enabled || !this.meter) {
-            return;
-        }
-        const counter = this.meter.createCounter(`custom_${name}`, {
-            description: `Custom metric: ${name}`,
-        });
-        counter.add(value, labels || {});
-    }
-    recordCustomHistogram(name, value, labels) {
-        if (!this.enabled || !this.meter) {
-            return;
-        }
-        const histogram = this.meter.createHistogram(`custom_${name}_histogram`, {
-            description: `Custom histogram: ${name}`,
-        });
-        histogram.record(value, labels || {});
-    }
-    // Health Checks
-    async getHealthMetrics() {
-        const memoryUsage = process.memoryUsage();
-        // Calculate error rate as percentage of errors vs total requests
-        const errorRate = this.requestCount > 0 ? (this.errorCount / this.requestCount) * 100 : 0;
-        // Calculate average response time
-        const averageResponseTime = this.responseTimeCount > 0
-            ? this.totalResponseTime / this.responseTimeCount
-            : 0;
-        return {
-            timestamp: Date.now(),
-            memoryUsage,
-            uptime: process.uptime(),
-            activeConnections: this.activeConnectionCount,
-            errorRate: Math.round(errorRate * 100) / 100, // Round to 2 decimal places
-            averageResponseTime: Math.round(averageResponseTime * 100) / 100, // Round to 2 decimal places
-        };
-    }
-    // Telemetry Status
-    isEnabled() {
-        return this.enabled;
-    }
-    getStatus() {
-        return {
-            enabled: this.enabled,
-            initialized: this.initialized,
-            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
-            service: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
-            version: process.env.OTEL_SERVICE_VERSION || "3.0.1",
-        };
-    }
-    // Helper methods
-    getDurationBucket(duration) {
-        if (duration < 100) {
-            return "fast";
-        }
-        if (duration < 500) {
-            return "medium";
-        }
-        if (duration < 1000) {
-            return "slow";
-        }
-        return "very_slow";
-    }
-    getStatusBucket(duration) {
-        if (duration < 200) {
-            return "excellent";
-        }
-        if (duration < 500) {
-            return "good";
-        }
-        if (duration < 1000) {
-            return "acceptable";
-        }
-        return "poor";
-    }
-    // Cleanup
-    async shutdown() {
-        if (this.enabled && this.sdk) {
-            try {
-                await this.sdk.shutdown();
-                this.initialized = false;
-                logger.debug("[Telemetry] SDK shutdown completed");
-            }
-            catch (error) {
-                logger.error("[Telemetry] Error during shutdown:", error);
-            }
-        }
-    }
-}

package/dist/client/telemetry/tracers.js

@@ -1,17 +0,0 @@
-import { trace } from "@opentelemetry/api";
-export const tracers = {
-    sdk: trace.getTracer("neurolink"),
-    provider: trace.getTracer("neurolink.provider"),
-    generation: trace.getTracer("neurolink.generation"),
-    stream: trace.getTracer("neurolink.stream"),
-    http: trace.getTracer("neurolink.http"),
-    mcp: trace.getTracer("neurolink.mcp"),
-    memory: trace.getTracer("neurolink.memory"),
-    redis: trace.getTracer("neurolink.redis"),
-    factory: trace.getTracer("neurolink.factory"),
-    rag: trace.getTracer("neurolink.rag"),
-    context: trace.getTracer("neurolink.context"),
-    middleware: trace.getTracer("neurolink.middleware"),
-    processor: trace.getTracer("neurolink.processor"),
-    file: trace.getTracer("neurolink.file"),
-};

package/dist/client/telemetry/withSpan.js

@@ -1,34 +0,0 @@
-import { SpanKind, SpanStatusCode, } from "@opentelemetry/api";
-export async function withSpan(options, fn) {
-    const { name, tracer, kind = SpanKind.INTERNAL, attributes } = options;
-    return tracer.startActiveSpan(name, { kind }, async (span) => {
-        if (attributes) {
-            for (const [key, value] of Object.entries(attributes)) {
-                if (value !== undefined) {
-                    span.setAttribute(key, value);
-                }
-            }
-        }
-        try {
-            const result = await fn(span);
-            span.setStatus({ code: SpanStatusCode.OK });
-            return result;
-        }
-        catch (error) {
-            span.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error),
-            });
-            if (error instanceof Error) {
-                span.recordException(error);
-            }
-            throw error;
-        }
-        finally {
-            span.end();
-        }
-    });
-}
-export async function withClientSpan(options, fn) {
-    return withSpan({ ...options, kind: SpanKind.CLIENT }, fn);
-}

package/dist/client/types/actionTypes.js

@@ -1,6 +0,0 @@
-// src/lib/types/actionTypes.ts
-/**
- * Type definitions for NeuroLink GitHub Action
- * @module actionTypes
- */
-export {};

package/dist/client/types/analytics.js

@@ -1,5 +0,0 @@
-/**
- * Analytics-related type definitions for NeuroLink
- * Comprehensive usage tracking, performance metrics, and cost analysis types
- */
-export {};

package/dist/client/types/authTypes.js

@@ -1,9 +0,0 @@
-/**
- * Auth-related type definitions for NeuroLink
- *
- * Canonical location for OAuth token storage types, token refresher contracts,
- * and multi-provider authentication types.
- * All auth type imports should reference this module (or the barrel re-export
- * via src/lib/types/index.ts).
- */
-export {};

package/dist/client/types/circuitBreakerErrors.js

@@ -1,34 +0,0 @@
-/**
- * Circuit Breaker Error Classes
- * Shared error types for circuit breaker implementations across the codebase.
- * Lives in types/ to avoid circular dependencies between utils/ and mcp/.
- */
-/**
- * Typed error thrown when a circuit breaker is open or half-open call limit is reached.
- * Contains structured metadata so callers can build actionable error messages
- * for AI models and downstream consumers.
- */
-export class CircuitBreakerOpenError extends Error {
-    /** The circuit breaker name (e.g., "tool-execution-bitbucket-server-add_comment") */
-    breakerName;
-    /** ISO timestamp when the circuit breaker will transition to half-open and allow a retry */
-    retryAfter;
-    /** Milliseconds until the circuit breaker will allow a retry */
-    retryAfterMs;
-    /** Current circuit breaker state ("open" or "half-open") */
-    breakerState;
-    /** Number of failures that caused the circuit to open */
-    failureCount;
-    constructor(options) {
-        const retryAfterStr = options.retryAfter.toISOString();
-        super(`Circuit breaker '${options.breakerName}' is ${options.breakerState}. ` +
-            `Tool temporarily unavailable after ${options.failureCount} failures. ` +
-            `Retry after: ${retryAfterStr} (${Math.ceil(options.retryAfterMs / 1000)}s).`);
-        this.name = "CircuitBreakerOpenError";
-        this.breakerName = options.breakerName;
-        this.retryAfter = retryAfterStr;
-        this.retryAfterMs = options.retryAfterMs;
-        this.breakerState = options.breakerState;
-        this.failureCount = options.failureCount;
-    }
-}

package/dist/client/types/cli.js

@@ -1,21 +0,0 @@
-/**
- * CLI-specific type definitions for NeuroLink
- */
-/**
- * Type guard for generate result
- */
-export function isGenerateResult(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "content" in value &&
-        typeof value.content === "string");
-}
-/**
- * Type guard for command result
- */
-export function isCommandResult(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "success" in value &&
-        typeof value.success === "boolean");
-}

package/dist/client/types/clientTypes.js

@@ -1,10 +0,0 @@
-/**
- * Client SDK Type Definitions
- *
- * Comprehensive type definitions for the NeuroLink client SDK system.
- * These types enable type-safe API access from JavaScript/TypeScript applications
- * and React applications with hooks for agents, workflows, and real-time streaming.
- *
- * @module @neurolink/client/types
- */
-export {};

package/dist/client/types/common.js

@@ -1,51 +0,0 @@
-/**
- * Common utility types for NeuroLink
- */
-/**
- * Type guard to check if value is Error
- */
-export function isError(value) {
-    return value instanceof Error;
-}
-/**
- * Type guard to check if value is ErrorInfo
- */
-export function isErrorInfo(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        "message" in value &&
-        typeof value.message === "string");
-}
-/**
- * Safe error message extraction
- */
-export function getErrorMessage(error) {
-    if (isError(error)) {
-        return error.message;
-    }
-    if (isErrorInfo(error)) {
-        return error.message;
-    }
-    if (typeof error === "string") {
-        return error;
-    }
-    return String(error);
-}
-/**
- * Safe error conversion
- */
-export function toErrorInfo(error) {
-    if (isError(error)) {
-        return {
-            message: error.message,
-            stack: error.stack,
-            code: error.code,
-        };
-    }
-    if (isErrorInfo(error)) {
-        return error;
-    }
-    return {
-        message: getErrorMessage(error),
-    };
-}

package/dist/client/types/configTypes.js

@@ -1,49 +0,0 @@
-/**
- * NeuroLink Configuration Types
- * Centralized configuration type definitions following the established architecture pattern
- */
-/**
- * Default configuration values
- */
-export const DEFAULT_CONFIG = {
-    providers: {
-        googleAi: {
-            model: "gemini-2.5-pro",
-            available: true,
-            features: ["streaming", "functionCalling"],
-        },
-    },
-    performance: {
-        cache: {
-            enabled: true,
-            ttlMs: 300000, // 5 minutes
-            strategy: "memory",
-            maxSize: 1000,
-        },
-        fallback: {
-            enabled: true,
-            maxAttempts: 3,
-            delayMs: 1000,
-            circuitBreaker: true,
-        },
-        timeoutMs: 30000, // 30 seconds
-        maxConcurrency: 5,
-    },
-    analytics: {
-        enabled: true,
-        trackTokens: true,
-        trackCosts: true,
-        trackPerformance: true,
-        retention: {
-            days: 30,
-            maxEntries: 10000,
-        },
-    },
-    tools: {
-        disableBuiltinTools: false,
-        allowCustomTools: true,
-        maxToolsPerProvider: 100,
-        enableMCPTools: true,
-    },
-    configVersion: "3.0.1",
-};