@juspay/neurolink 9.30.0 → 9.31.0

package/dist/client/telemetry/attributes.js

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,26 @@
+// 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

@@ -0,0 +1,308 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,34 @@
+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

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

package/dist/client/types/analytics.js

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

package/dist/client/types/authTypes.js

@@ -0,0 +1,8 @@
+/**
+ * Auth-related type definitions for NeuroLink
+ *
+ * Canonical location for OAuth token storage types and token refresher contracts.
+ * 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

@@ -0,0 +1,34 @@
+/**
+ * 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

@@ -0,0 +1,21 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,51 @@
+/**
+ * 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

@@ -0,0 +1,49 @@
+/**
+ * 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",
+};