@bluefly/openstandardagents 0.4.0 → 0.4.1

package/dist/services/export/langchain/callbacks-generator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LangChain Callbacks Generator
+ *
+ * Generates observability and callback handlers for LangChain agents:
+ * - LangSmith tracing
+ * - LangFuse observability
+ * - OpenTelemetry integration
+ * - Custom callback handlers
+ *
+ * SOLID: Single Responsibility - Callback configuration generation
+ * DRY: Reusable callback patterns
+ */
+import type { OssaAgent } from '../../../types/index.js';
+/**
+ * Callback configuration options
+ */
+export interface CallbackConfig {
+    /**
+     * Enable LangSmith tracing
+     */
+    langsmith?: boolean;
+    /**
+     * Enable LangFuse observability
+     */
+    langfuse?: boolean;
+    /**
+     * Enable OpenTelemetry
+     */
+    opentelemetry?: boolean;
+    /**
+     * Custom callback handlers
+     */
+    custom?: {
+        onStart?: boolean;
+        onEnd?: boolean;
+        onError?: boolean;
+        onToken?: boolean;
+    };
+    /**
+     * Log level
+     */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+}
+/**
+ * Callbacks Generator
+ */
+export declare class CallbacksGenerator {
+    /**
+     * Generate callbacks.py with observability integrations
+     */
+    generate(manifest: OssaAgent, config?: CallbackConfig): string;
+    private generateHeader;
+    private generateImports;
+    private generateConfiguration;
+    private generateLangSmithSetup;
+    private generateLangFuseHandler;
+    private generateOpenTelemetryHandler;
+    private generateCustomHandlers;
+    private generateCostTrackingHandler;
+    private generateCallbackManager;
+    private generateHelpers;
+}
+//# sourceMappingURL=callbacks-generator.d.ts.map

package/dist/services/export/langchain/callbacks-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks-generator.d.ts","sourceRoot":"","sources":["../../../../src/services/export/langchain/callbacks-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAChD;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAE,cAAmB,GAAG,MAAM;IA6ClE,OAAO,CAAC,cAAc;IAatB,OAAO,CAAC,eAAe;IA+BvB,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,sBAAsB;IAiC9B,OAAO,CAAC,uBAAuB;IAiC/B,OAAO,CAAC,4BAA4B;IA6DpC,OAAO,CAAC,sBAAsB;IA4C9B,OAAO,CAAC,2BAA2B;IA8EnC,OAAO,CAAC,uBAAuB;IAgD/B,OAAO,CAAC,eAAe;CAuBxB"}

package/dist/services/export/langchain/callbacks-generator.js

@@ -0,0 +1,408 @@
+/**
+ * LangChain Callbacks Generator
+ *
+ * Generates observability and callback handlers for LangChain agents:
+ * - LangSmith tracing
+ * - LangFuse observability
+ * - OpenTelemetry integration
+ * - Custom callback handlers
+ *
+ * SOLID: Single Responsibility - Callback configuration generation
+ * DRY: Reusable callback patterns
+ */
+/**
+ * Callbacks Generator
+ */
+export class CallbacksGenerator {
+    /**
+     * Generate callbacks.py with observability integrations
+     */
+    generate(manifest, config = {}) {
+        const agentName = manifest.metadata?.name || 'agent';
+        const sections = [];
+        // Header
+        sections.push(this.generateHeader(agentName));
+        // Imports
+        sections.push(this.generateImports(config));
+        // Configuration
+        sections.push(this.generateConfiguration(config));
+        // LangSmith integration
+        if (config.langsmith !== false) {
+            sections.push(this.generateLangSmithSetup());
+        }
+        // LangFuse integration
+        if (config.langfuse) {
+            sections.push(this.generateLangFuseHandler());
+        }
+        // OpenTelemetry integration
+        if (config.opentelemetry) {
+            sections.push(this.generateOpenTelemetryHandler());
+        }
+        // Custom handlers
+        if (config.custom) {
+            sections.push(this.generateCustomHandlers(config.custom));
+        }
+        // Cost tracking handler
+        sections.push(this.generateCostTrackingHandler());
+        // Main callback manager
+        sections.push(this.generateCallbackManager(config));
+        // Helper functions
+        sections.push(this.generateHelpers());
+        return sections.join('\n\n');
+    }
+    generateHeader(agentName) {
+        return `"""
+Callbacks and Observability for ${agentName}
+
+Provides comprehensive callback handlers for:
+- LangSmith tracing (production-ready)
+- LangFuse observability
+- OpenTelemetry instrumentation
+- Cost tracking and token usage
+- Custom event handlers
+"""`;
+    }
+    generateImports(config) {
+        const imports = [
+            'import os',
+            'import time',
+            'from typing import Any, Dict, List, Optional, Union',
+            'from datetime import datetime',
+            'from langchain.callbacks.base import BaseCallbackHandler',
+            'from langchain.callbacks.manager import CallbackManager',
+            'from langchain.schema import AgentAction, AgentFinish, LLMResult',
+        ];
+        if (config.langsmith !== false) {
+            imports.push('from langchain.callbacks.tracers import LangChainTracer');
+        }
+        if (config.langfuse) {
+            imports.push('from langfuse.callback import CallbackHandler as LangfuseHandler');
+        }
+        if (config.opentelemetry) {
+            imports.push('from opentelemetry import trace', 'from opentelemetry.sdk.trace import TracerProvider', 'from opentelemetry.sdk.trace.export import BatchSpanProcessor', 'from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter');
+        }
+        return imports.join('\n');
+    }
+    generateConfiguration(config) {
+        return `# Callback Configuration
+LOG_LEVEL = os.getenv("CALLBACK_LOG_LEVEL", "${config.logLevel || 'info'}").lower()
+LANGSMITH_ENABLED = os.getenv("LANGSMITH_ENABLED", "${config.langsmith !== false ? 'true' : 'false'}").lower() == "true"
+LANGFUSE_ENABLED = os.getenv("LANGFUSE_ENABLED", "${config.langfuse ? 'true' : 'false'}").lower() == "true"
+OTEL_ENABLED = os.getenv("OTEL_ENABLED", "${config.opentelemetry ? 'true' : 'false'}").lower() == "true"`;
+    }
+    generateLangSmithSetup() {
+        return `def setup_langsmith() -> Optional[LangChainTracer]:
+    """
+    Setup LangSmith tracing
+
+    Environment variables:
+    - LANGCHAIN_API_KEY: LangSmith API key
+    - LANGCHAIN_PROJECT: Project name
+    - LANGCHAIN_ENDPOINT: API endpoint (optional)
+    """
+    if not LANGSMITH_ENABLED:
+        return None
+
+    api_key = os.getenv("LANGCHAIN_API_KEY")
+    if not api_key:
+        print("Warning: LANGCHAIN_API_KEY not set, LangSmith tracing disabled")
+        return None
+
+    project = os.getenv("LANGCHAIN_PROJECT", "default")
+    endpoint = os.getenv("LANGCHAIN_ENDPOINT", "https://api.smith.langchain.com")
+
+    try:
+        tracer = LangChainTracer(
+            project_name=project,
+            client=None,  # Will use env vars
+        )
+        print(f"✓ LangSmith tracing enabled: project={project}")
+        return tracer
+    except Exception as e:
+        print(f"Warning: Failed to setup LangSmith: {e}")
+        return None`;
+    }
+    generateLangFuseHandler() {
+        return `def setup_langfuse() -> Optional[LangfuseHandler]:
+    """
+    Setup LangFuse observability
+
+    Environment variables:
+    - LANGFUSE_PUBLIC_KEY: Public key
+    - LANGFUSE_SECRET_KEY: Secret key
+    - LANGFUSE_HOST: Host URL (optional)
+    """
+    if not LANGFUSE_ENABLED:
+        return None
+
+    public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+    secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+
+    if not public_key or not secret_key:
+        print("Warning: LangFuse credentials not set, observability disabled")
+        return None
+
+    try:
+        handler = LangfuseHandler(
+            public_key=public_key,
+            secret_key=secret_key,
+            host=os.getenv("LANGFUSE_HOST"),
+        )
+        print("✓ LangFuse observability enabled")
+        return handler
+    except Exception as e:
+        print(f"Warning: Failed to setup LangFuse: {e}")
+        return None`;
+    }
+    generateOpenTelemetryHandler() {
+        return `def setup_opentelemetry():
+    """
+    Setup OpenTelemetry tracing
+
+    Environment variables:
+    - OTEL_EXPORTER_OTLP_ENDPOINT: OTLP endpoint
+    - OTEL_SERVICE_NAME: Service name
+    """
+    if not OTEL_ENABLED:
+        return
+
+    endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+    if not endpoint:
+        print("Warning: OTEL_EXPORTER_OTLP_ENDPOINT not set, OpenTelemetry disabled")
+        return
+
+    try:
+        provider = TracerProvider()
+        processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint))
+        provider.add_span_processor(processor)
+        trace.set_tracer_provider(provider)
+
+        service_name = os.getenv("OTEL_SERVICE_NAME", "langchain-agent")
+        print(f"✓ OpenTelemetry enabled: service={service_name}")
+    except Exception as e:
+        print(f"Warning: Failed to setup OpenTelemetry: {e}")
+
+
+class OpenTelemetryCallbackHandler(BaseCallbackHandler):
+    """OpenTelemetry callback handler"""
+
+    def __init__(self):
+        super().__init__()
+        self.tracer = trace.get_tracer(__name__)
+        self.spans = {}
+
+    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs):
+        """Start LLM span"""
+        run_id = kwargs.get("run_id")
+        span = self.tracer.start_span(f"llm.{serialized.get('name', 'unknown')}")
+        span.set_attribute("prompts.count", len(prompts))
+        self.spans[str(run_id)] = span
+
+    def on_llm_end(self, response: LLMResult, **kwargs):
+        """End LLM span"""
+        run_id = kwargs.get("run_id")
+        span = self.spans.pop(str(run_id), None)
+        if span:
+            span.set_attribute("generations.count", len(response.generations))
+            span.end()
+
+    def on_llm_error(self, error: Exception, **kwargs):
+        """Record LLM error"""
+        run_id = kwargs.get("run_id")
+        span = self.spans.pop(str(run_id), None)
+        if span:
+            span.record_exception(error)
+            span.end()`;
+    }
+    generateCustomHandlers(custom) {
+        return `class CustomCallbackHandler(BaseCallbackHandler):
+    """Custom callback handler with event hooks"""
+
+    def __init__(self, log_level: str = "info"):
+        super().__init__()
+        self.log_level = log_level
+        self.start_time = None
+        self.events = []
+
+    ${custom.onStart ? `def on_chain_start(self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs):
+        """Called when chain starts"""
+        self.start_time = time.time()
+        if self.log_level in ["debug", "info"]:
+            print(f"▶ Chain started: {serialized.get('name', 'unknown')}")
+            if self.log_level == "debug":
+                print(f"  Inputs: {inputs}")
+
+    def on_agent_action(self, action: AgentAction, **kwargs):
+        """Called when agent takes action"""
+        if self.log_level in ["debug", "info"]:
+            print(f"  → Action: {action.tool} - {action.tool_input}")` : ''}
+
+    ${custom.onEnd ? `def on_chain_end(self, outputs: Dict[str, Any], **kwargs):
+        """Called when chain ends"""
+        duration = time.time() - self.start_time if self.start_time else 0
+        if self.log_level in ["debug", "info"]:
+            print(f"✓ Chain completed: {duration:.2f}s")
+            if self.log_level == "debug":
+                print(f"  Outputs: {outputs}")` : ''}
+
+    ${custom.onError ? `def on_chain_error(self, error: Exception, **kwargs):
+        """Called when chain errors"""
+        print(f"✗ Chain error: {error}")
+        if self.log_level == "debug":
+            import traceback
+            traceback.print_exc()` : ''}
+
+    ${custom.onToken ? `def on_llm_new_token(self, token: str, **kwargs):
+        """Called when new token is generated"""
+        if self.log_level == "debug":
+            print(token, end="", flush=True)` : ''}`;
+    }
+    generateCostTrackingHandler() {
+        return `class CostTrackingHandler(BaseCallbackHandler):
+    """Track token usage and costs"""
+
+    # Pricing per 1M tokens (as of 2026)
+    PRICING = {
+        "gpt-4": {"input": 30.0, "output": 60.0},
+        "gpt-4-turbo": {"input": 10.0, "output": 30.0},
+        "gpt-3.5-turbo": {"input": 0.5, "output": 1.5},
+        "claude-3-opus": {"input": 15.0, "output": 75.0},
+        "claude-3-sonnet": {"input": 3.0, "output": 15.0},
+        "claude-3-haiku": {"input": 0.25, "output": 1.25},
+        "claude-sonnet-4": {"input": 3.0, "output": 15.0},
+    }
+
+    def __init__(self):
+        super().__init__()
+        self.total_tokens = 0
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.total_cost = 0.0
+        self.model_name = None
+
+    def on_llm_start(self, serialized: Dict[str, Any], prompts: List[str], **kwargs):
+        """Capture model name"""
+        self.model_name = serialized.get("name", "unknown")
+
+    def on_llm_end(self, response: LLMResult, **kwargs):
+        """Track token usage"""
+        if not response.llm_output:
+            return
+
+        token_usage = response.llm_output.get("token_usage", {})
+        prompt_tokens = token_usage.get("prompt_tokens", 0)
+        completion_tokens = token_usage.get("completion_tokens", 0)
+        total = prompt_tokens + completion_tokens
+
+        self.prompt_tokens += prompt_tokens
+        self.completion_tokens += completion_tokens
+        self.total_tokens += total
+
+        # Calculate cost
+        model_key = self._normalize_model_name(self.model_name or "")
+        pricing = self.PRICING.get(model_key, {"input": 0, "output": 0})
+
+        input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
+        output_cost = (completion_tokens / 1_000_000) * pricing["output"]
+        self.total_cost += input_cost + output_cost
+
+        if LOG_LEVEL in ["debug", "info"]:
+            print(f"  Tokens: {prompt_tokens} in, {completion_tokens} out = \${input_cost + output_cost:.6f}")
+
+    def _normalize_model_name(self, model: str) -> str:
+        """Normalize model name for pricing lookup"""
+        model = model.lower()
+        for key in self.PRICING.keys():
+            if key in model:
+                return key
+        return "unknown"
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Get cost tracking summary"""
+        return {
+            "total_tokens": self.total_tokens,
+            "prompt_tokens": self.prompt_tokens,
+            "completion_tokens": self.completion_tokens,
+            "total_cost": round(self.total_cost, 6),
+            "model": self.model_name,
+        }
+
+    def reset(self):
+        """Reset tracking counters"""
+        self.total_tokens = 0
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.total_cost = 0.0`;
+    }
+    generateCallbackManager(config) {
+        return `def get_callbacks() -> CallbackManager:
+    """
+    Get configured callback manager with all enabled handlers
+    """
+    handlers = []
+
+    # LangSmith tracing
+    if LANGSMITH_ENABLED:
+        langsmith = setup_langsmith()
+        if langsmith:
+            handlers.append(langsmith)
+
+    # LangFuse observability
+    if LANGFUSE_ENABLED:
+        langfuse = setup_langfuse()
+        if langfuse:
+            handlers.append(langfuse)
+
+    # OpenTelemetry
+    if OTEL_ENABLED:
+        setup_opentelemetry()
+        handlers.append(OpenTelemetryCallbackHandler())
+
+    # Custom handlers
+    ${config.custom ? 'handlers.append(CustomCallbackHandler(log_level=LOG_LEVEL))' : ''}
+
+    # Cost tracking (always enabled)
+    cost_tracker = CostTrackingHandler()
+    handlers.append(cost_tracker)
+
+    manager = CallbackManager(handlers=handlers)
+
+    if LOG_LEVEL in ["debug", "info"]:
+        print(f"✓ Callbacks initialized: {len(handlers)} handlers")
+
+    return manager
+
+
+# Global cost tracker for access
+_cost_tracker = CostTrackingHandler()
+
+
+def get_cost_tracker() -> CostTrackingHandler:
+    """Get global cost tracker instance"""
+    return _cost_tracker`;
+    }
+    generateHelpers() {
+        return `def print_cost_summary(tracker: Optional[CostTrackingHandler] = None):
+    """Print cost tracking summary"""
+    tracker = tracker or _cost_tracker
+    summary = tracker.get_summary()
+
+    print("\\n" + "=" * 50)
+    print("Cost Summary")
+    print("=" * 50)
+    print(f"Model: {summary['model']}")
+    print(f"Total Tokens: {summary['total_tokens']:,}")
+    print(f"  Prompt: {summary['prompt_tokens']:,}")
+    print(f"  Completion: {summary['completion_tokens']:,}")
+    print(f"Total Cost: \${summary['total_cost']:.6f}")
+    print("=" * 50)
+
+
+def reset_cost_tracking(tracker: Optional[CostTrackingHandler] = None):
+    """Reset cost tracking counters"""
+    tracker = tracker or _cost_tracker
+    tracker.reset()
+    print("✓ Cost tracking reset")`;
+    }
+}
+//# sourceMappingURL=callbacks-generator.js.map

package/dist/services/export/langchain/callbacks-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks-generator.js","sourceRoot":"","sources":["../../../../src/services/export/langchain/callbacks-generator.ts"],"names":[],"mappings":"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"}

package/dist/services/export/langchain/error-handling-generator.d.ts

@@ -0,0 +1,76 @@
+/**
+ * LangChain Error Handling Generator
+ *
+ * Generates production-grade error handling for LangChain agents:
+ * - Retry logic with exponential backoff
+ * - Circuit breaker pattern
+ * - Rate limiting
+ * - Error classification and recovery strategies
+ * - Fallback mechanisms
+ *
+ * SOLID: Single Responsibility - Error handling configuration
+ * DRY: Reusable error handling patterns
+ */
+import type { OssaAgent } from '../../../types/index.js';
+/**
+ * Error handling configuration
+ */
+export interface ErrorHandlingConfig {
+    /**
+     * Enable retry logic
+     */
+    retry?: {
+        enabled?: boolean;
+        maxAttempts?: number;
+        exponentialBackoff?: boolean;
+        initialDelay?: number;
+        maxDelay?: number;
+        retryableErrors?: string[];
+    };
+    /**
+     * Enable circuit breaker
+     */
+    circuitBreaker?: {
+        enabled?: boolean;
+        failureThreshold?: number;
+        resetTimeout?: number;
+        halfOpenMaxAttempts?: number;
+    };
+    /**
+     * Rate limiting
+     */
+    rateLimit?: {
+        enabled?: boolean;
+        maxRequests?: number;
+        windowSeconds?: number;
+    };
+    /**
+     * Fallback strategies
+     */
+    fallback?: {
+        enabled?: boolean;
+        defaultResponse?: string;
+        useCachedResponses?: boolean;
+    };
+}
+/**
+ * Error Handling Generator
+ */
+export declare class ErrorHandlingGenerator {
+    /**
+     * Generate error_handling.py with production error handling
+     */
+    generate(manifest: OssaAgent, config?: ErrorHandlingConfig): string;
+    private generateHeader;
+    private generateImports;
+    private generateConfiguration;
+    private generateErrorClassification;
+    private generateRetryDecorator;
+    private generateCircuitBreaker;
+    private generateRateLimiter;
+    private generateFallbackHandler;
+    private generateErrorRecovery;
+    private generateMainErrorHandler;
+    private generateUtilities;
+}
+//# sourceMappingURL=error-handling-generator.d.ts.map

package/dist/services/export/langchain/error-handling-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling-generator.d.ts","sourceRoot":"","sources":["../../../../src/services/export/langchain/error-handling-generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;KAC5B,CAAC;IAEF;;OAEG;IACH,cAAc,CAAC,EAAE;QACf,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B,CAAC;IAEF;;OAEG;IACH,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,EAAE;QACT,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B,CAAC;CACH;AAED;;GAEG;AACH,qBAAa,sBAAsB;IACjC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAE,mBAAwB,GAAG,MAAM;IA+CvE,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,qBAAqB;IA2B7B,OAAO,CAAC,2BAA2B;IAwDnC,OAAO,CAAC,sBAAsB;IAqE9B,OAAO,CAAC,sBAAsB;IAkG9B,OAAO,CAAC,mBAAmB;IA8C3B,OAAO,CAAC,uBAAuB;IA2C/B,OAAO,CAAC,qBAAqB;IAoC7B,OAAO,CAAC,wBAAwB;IAkChC,OAAO,CAAC,iBAAiB;CAoC1B"}