@robota-sdk/agent-core 3.0.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,180 @@
+# @robota-sdk/agent-core
+
+## 2.0.9
+
+### Patch Changes
+
+- Add environment-specific builds and conditional exports for optimal browser compatibility
+
+  This update introduces major build optimizations for better browser performance:
+
+  ## 🚀 Environment-Specific Builds
+  - **Node.js builds**: `dist/node/` with full ESM and CJS support
+  - **Browser builds**: `dist/browser/` with optimized ESM bundles
+  - **Automatic selection**: Bundlers automatically choose the right build
+
+  ## 📦 Bundle Size Optimizations
+  - **team package**: 36% smaller browser bundles (37.52KB → 24.12KB)
+  - **sessions package**: 48% smaller browser bundles (10.64KB → 5.55KB)
+  - **Tree-shaking**: Eliminates Node.js-specific code from browser builds
+  - **Production optimizations**: Removes console logs and debug code in browser builds
+
+  ## 🔧 Conditional Exports
+
+  All packages now support conditional exports for seamless environment detection:
+
+  ```json
+  {
+    "exports": {
+      "node": "./dist/node/index.js",
+      "browser": "./dist/browser/index.js",
+      "default": "./dist/node/index.js"
+    }
+  }
+  ```
+
+  ## 🌐 Enhanced Browser Support
+  - **Zero breaking changes**: Existing code continues to work unchanged
+  - **Better performance**: Optimized bundles for faster loading
+  - **Smaller footprint**: Reduced JavaScript bundle sizes for web applications
+  - **Universal API**: Same API works across all environments
+
+  This update completes the browser compatibility optimization phase, making Robota SDK production-ready for web applications with optimal performance characteristics.
+
+## 2.0.8
+
+### Patch Changes
+
+- # Model Configuration Refactoring
+
+  ## 🚀 **Breaking Changes**
+
+  ### **Provider Interface Simplification**
+  - **OpenAI Provider**: Removed `model`, `temperature`, `maxTokens`, `topP` from provider options
+  - **Anthropic Provider**: Removed `model`, `temperature`, `maxTokens` from provider options
+  - **Google Provider**: Removed `model`, `temperature`, `maxTokens` from provider options
+  - **All Providers**: `client` is now optional, automatically created from `apiKey`
+
+  ### **Centralized Model Configuration**
+  - Model configuration is now exclusively handled through `defaultModel` in Robota constructor
+  - Providers are simplified to handle only connection-related settings
+  - Runtime model switching via `setModel()` method is now the recommended approach
+
+  ## ✨ **Improvements**
+
+  ### **Simplified Provider Creation**
+
+  ```typescript
+  // Before
+  const provider = new OpenAIProvider({
+    client: openaiClient,
+    model: 'gpt-3.5-turbo',
+  });
+
+  // After
+  const provider = new OpenAIProvider({
+    apiKey: process.env.OPENAI_API_KEY,
+  });
+  ```
+
+  ### **Enhanced Validation**
+  - Added strict validation for required model configuration
+  - Removed default model fallbacks to prevent ambiguous behavior
+  - Clear error messages when model is not specified
+
+  ### **Documentation Updates**
+  - Updated all README files with new usage patterns
+  - Regenerated API documentation
+  - Updated all example files (11 examples)
+
+  ## 🔧 **Migration Guide**
+  1. **Remove model settings from Provider constructors**
+  2. **Use `apiKey` instead of `client` injection (recommended)**
+  3. **Ensure `defaultModel` is properly configured in Robota constructor**
+  4. **Update any hardcoded model references to use runtime switching**
+
+  ## 🎯 **Benefits**
+  - **Eliminates configuration confusion** - Single source of truth for models
+  - **Simplifies provider setup** - Just provide API credentials
+  - **Enables better runtime control** - Centralized model management
+  - **Improves consistency** - All providers follow same pattern
+
+## 2.0.7
+
+### Patch Changes
+
+- Browser compatibility improvements
+  - feat: Implement SimpleLogger system to replace direct console usage for better browser compatibility
+  - feat: Centralize SimpleLogger in @robota-sdk/agent-core package and export for other packages
+  - feat: Add support for silent and stderr-only logging modes via SilentLogger and StderrLogger
+  - refactor: Update all packages (@robota-sdk/agent-provider-openai, @robota-sdk/agent-provider-anthropic, etc.) to use centralized SimpleLogger
+  - chore: Add ESLint rules to prevent direct console usage while allowing legitimate cases
+  - fix: Remove unused AIProvider import from examples to clean up warnings
+
+  These changes ensure the SDK works properly in browser environments by removing Node.js-specific console behavior while maintaining full backward compatibility.
+
+## 2.0.6
+
+### Patch Changes
+
+- Add browser compatibility by removing Node.js dependencies
+  - Replace NodeJS.Timeout with cross-platform TimerId type
+  - Remove process.env dependency from logger configuration
+  - Replace Node.js crypto module with jsSHA library for webhook signatures
+  - Update OpenAI stream handlers to work in browser environments
+  - Maintain 100% backward compatibility with existing Node.js applications
+
+  This update enables Robota SDK to run seamlessly in both Node.js and browser environments without breaking changes.
+
+## 2.0.5
+
+### Patch Changes
+
+- ## 🎯 TypeScript Declaration File Optimization
+
+## 2.0.4
+
+### Patch Changes
+
+- 9f17ac6: Restore README.md files and prevent deletion during build process
+
+## 2.0.3
+
+## 2.0.2
+
+### Patch Changes
+
+- Fix npm package documentation by ensuring README.md files are included
+
+## 2.0.1
+
+### Patch Changes
+
+- Remove unused dependencies from agents and sessions packages
+
+## 2.0.0
+
+### Major Changes
+
+- a3a464c: # Robota SDK v2.0.0-rc.1 - Unified Architecture
+
+  ## 🚀 Major Changes
+
+  ### New Unified Core
+  - **@robota-sdk/agent-core**: New unified core package consolidating all functionality
+  - **Zero `any` types**: Complete TypeScript type safety across all packages
+  - **Provider-agnostic design**: Seamless switching between OpenAI, Anthropic, and Google
+
+  ### Key Features
+  - **Multi-Provider Support**: Dynamic provider switching with type safety
+  - **Advanced Function Calling**: Type-safe tool system with Zod validation
+  - **Real-time Streaming**: Improved streaming with proper error handling
+  - **Task Delegation**: Improved delegated workflow support
+  - **Plugin Architecture**: Comprehensive plugin system with facade pattern
+
+  ### Breaking Changes
+  - `@robota-sdk/core` functionality moved to `@robota-sdk/agent-core`
+  - Redesigned provider interfaces with generic type parameters
+  - Updated agent configuration format
+
+  Complete architecture overhaul focused on type safety and developer experience.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Robota Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,230 @@
+# @robota-sdk/agent-core
+
+The comprehensive AI agent framework with type-safe architecture and advanced plugin system.
+
+## Overview
+
+The `@robota-sdk/agent-core` package is the unified core of the Robota SDK, providing a complete AI agent system with advanced capabilities for conversation management, tool execution, and extensible plugin architecture.
+
+## Installation
+
+```bash
+npm install @robota-sdk/agent-core
+# or
+pnpm add @robota-sdk/agent-core
+```
+
+## Quick Start
+
+```typescript
+import { Robota } from '@robota-sdk/agent-core';
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+
+const openaiProvider = new OpenAIProvider({ apiKey: 'sk-...' });
+
+const agent = new Robota({
+  name: 'MyAgent',
+  aiProviders: [openaiProvider],
+  defaultModel: {
+    provider: 'openai',
+    model: 'gpt-4',
+    systemMessage: 'You are a helpful assistant.',
+  },
+});
+
+const response = await agent.run('Hello, world!');
+console.log(response);
+```
+
+### Browser Quick Start
+
+```typescript
+import { Robota, LoggingPlugin, UsagePlugin } from '@robota-sdk/agent-core';
+import { OpenAIProvider } from '@robota-sdk/agent-provider-openai';
+
+const openaiProvider = new OpenAIProvider({
+  apiKey: process.env.NEXT_PUBLIC_OPENAI_API_KEY, // or proxy endpoint
+});
+
+// Browser-optimized configuration
+const agent = new Robota({
+  name: 'BrowserAgent',
+  aiProviders: [openaiProvider],
+  defaultModel: {
+    provider: 'openai',
+    model: 'gpt-3.5-turbo',
+  },
+  plugins: [
+    new LoggingPlugin({ strategy: 'console' }), // Console logging
+    new UsagePlugin({ strategy: 'memory' }), // Memory storage
+  ],
+});
+
+const response = await agent.run('Hello from browser!');
+console.log(response);
+```
+
+## Key Features
+
+### 🌐 Cross-Platform Compatibility
+
+- **Universal Runtime Support**: Works seamlessly in Node.js, browsers, and WebWorkers
+- **Zero Breaking Changes**: Existing Node.js code runs unchanged in browsers
+- **Pure JavaScript Implementation**: No Node.js-specific dependencies in core functionality
+- **Browser-Optimized Storage**: Memory-based alternatives for file system operations
+- **Secure API Patterns**: Proxy server support for secure browser deployments
+
+### 🤖 Agent System
+
+- **Type-Safe Architecture**: Full TypeScript support with generic type parameters
+- **Robota Class**: Complete AI agent implementation with conversation + tool system + plugin integration
+- **Stateless Service Layer**: ConversationService, ToolExecutionService, ExecutionService for business logic
+- **Manager Layer**: AIProviders, Tools, AgentFactory, Plugins, ConversationHistory for resource management
+- **Parallel Tool Execution**: Concurrent multi-tool calling support
+
+### 🌊 Streaming Response System
+
+- **Real-time Streaming**: Full streaming support across all AI providers
+- **Modular Architecture**: Separate streaming/parsing logic for each provider
+- **Provider Support**: OpenAI, Anthropic, Google with dedicated stream handlers
+
+### 🔧 Tool System
+
+- **Type-Safe Tools**: `BaseTool<TParameters, TResult>` with compile-time type checking
+- **ToolRegistry**: Schema storage and validation system
+- **Function Tools**: Zod schema-based function tool implementation
+- **OpenAPI/MCP Support**: Basic structure for extensibility
+
+## Recent Updates
+
+- Tool execution results preserve `executionId` mappings for both success and failure to keep deterministic ordering.
+
+### 🔌 Plugin System
+
+Eight core plugins with type-safe configuration and BasePluginOptions integration:
+
+- **ConversationHistoryPlugin**: Comprehensive conversation storage with support for memory, file, and database backends. Features auto-save, batch processing, and configurable limits.
+- **UsagePlugin**: Advanced usage analytics including token counting, cost calculation, aggregated statistics, and multiple storage strategies (memory/file/remote).
+- **LoggingPlugin**: Multi-level logging system with console, file, and remote endpoints. Supports custom formatters, batch processing, and structured logging.
+- **PerformancePlugin**: Real-time performance monitoring including execution time tracking, memory usage, CPU metrics, and customizable performance thresholds.
+- **ErrorHandlingPlugin**: Robust error management with multiple strategies (simple, exponential-backoff, circuit-breaker, silent) and custom error handlers.
+- **LimitsPlugin**: Advanced rate limiting with token bucket, sliding window, and fixed window strategies. Supports cost tracking and custom calculators.
+- **EventEmitterPlugin**: Comprehensive event system with async/sync event handling, filtering, buffering, and lifecycle event tracking.
+- **WebhookPlugin**: HTTP webhook notifications with batch processing, retry logic, custom transformers, and concurrent request management.
+
+#### Plugin Features
+
+- **Type Safety**: All plugins extend BasePluginOptions for consistent configuration
+- **Lifecycle Integration**: Automatic integration with agent lifecycle events
+- **Resource Management**: Built-in cleanup and resource optimization
+- **Performance Monitoring**: All plugins include built-in statistics and monitoring
+- **Error Resilience**: Graceful error handling across all plugin operations
+
+#### Plugin Control and Configuration
+
+- **Clear Disable Options**: Every plugin provides multiple ways to disable functionality
+- **No Arbitrary Decisions**: Plugins avoid making policy decisions without explicit configuration
+- **Explicit Configuration**: All automatic behaviors can be controlled through configuration
+- **Silent Modes**: Most plugins support 'silent' strategies for performance-critical scenarios
+
+```typescript
+// Complete plugin disable
+const agent = new Robota({
+  plugins: [], // No plugins
+});
+
+// Selective plugin disable
+const agent = new Robota({
+  plugins: [
+    new LoggingPlugin({ strategy: 'silent', enabled: false }),
+    new LimitsPlugin({ strategy: 'none' }),
+    new UsagePlugin({ strategy: 'silent' }),
+  ],
+});
+```
+
+#### Plugin Documentation
+
+- **[Plugin Guide](./docs/PLUGINS.md)**: Unified plugin behavior and configuration guide
+
+### 🔒 Type Safety Features
+
+- **Generic Type Parameters**: `BaseAgent<TConfig, TContext, TMessage>`
+- **Provider Agnostic**: Dynamic provider registration with type safety
+- **Extended RunContext**: Provider-specific options with type preservation
+- **Plugin Type Parameters**: `BasePlugin<TOptions, TStats>` for specialized configurations
+
+## Architecture
+
+### Core Abstraction Layers
+
+```
+BaseAgent<TConfig, TContext, TMessage> (Abstract Class)
+└── Robota (Implementation - AI conversation + tool system + plugins)
+
+BaseAIProvider<TConfig, TMessage, TResponse>
+├── OpenAIProvider (via @robota-sdk/agent-provider-openai)
+├── AnthropicProvider (via @robota-sdk/agent-provider-anthropic)
+└── GoogleProvider (via @robota-sdk/agent-provider-google)
+
+BaseTool<TParameters, TResult>
+├── FunctionTool (Zod schema-based)
+├── OpenAPITool (API specification-based)
+└── MCPTool (Model Context Protocol)
+
+BasePlugin<TOptions, TStats>
+├── Core Plugins (8 essential plugins)
+└── Custom Plugins (User-defined extensions)
+```
+
+### Module Structure
+
+```
+packages/agents/src/
+├── abstracts/           # Abstract base classes with type parameters
+├── interfaces/          # Type-safe interface definitions
+├── agents/             # Main agent system
+│   ├── managers/       # Resource managers
+│   ├── services/       # Stateless business logic
+│   └── tools/          # Tool system
+├── plugins/            # Plugin system with Facade pattern
+└── utils/              # Core utilities
+```
+
+## Development
+
+See [Development Guide](./docs/DEVELOPMENT.md) for development guidelines.
+
+## API Reference
+
+See [api.md](api.md) for complete API documentation.
+
+## Architecture Guide
+
+See [Architecture](./docs/ARCHITECTURE.md) for detailed architecture information.
+
+## Examples
+
+- [Basic Usage](../../../docs/examples/basic-usage.md)
+- [Browser Usage](../../../docs/examples/browser-usage.md) 🌐
+- [Tool Integration](../../../docs/examples/tool-integration.md)
+- [Plugin Development](../../../docs/examples/plugin-development.md)
+- [Streaming Responses](../../../docs/examples/streaming.md)
+
+## Package Compatibility
+
+### Integrated Packages
+
+- **@robota-sdk/agent-provider-openai**: Complete agents standard migration
+- **@robota-sdk/agent-provider-anthropic**: Complete agents standard migration
+- **@robota-sdk/agent-provider-google**: Complete agents standard migration
+- **@robota-sdk/agent-team**: assignTask MCP tool collection (team creation removed)
+
+### Deprecated Packages
+
+- **@robota-sdk/core**: Deprecated - functionality moved to agents
+- **@robota-sdk/agent-tools**: Deprecated - functionality moved to agents
+
+## License
+
+MIT

package/dist/abstracts/abstract-agent.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Abstract Agent Base Class
+ *
+ * 🎯 ABSTRACT CLASS - DO NOT DEPEND ON CONCRETE IMPLEMENTATIONS
+ *
+ * This class defines the foundational lifecycle for agent implementations.
+ * Subclasses provide provider/tool-specific behavior while inheriting the
+ * shared guarantees around initialization, history, and disposal.
+ */
+import type { IAgent, IAgentConfig, TUniversalMessage, IRunOptions } from '../interfaces/agent';
+export declare abstract class AbstractAgent<TConfig = IAgentConfig, TContext = IRunOptions, TMessage = TUniversalMessage> implements IAgent<TConfig, TContext, TMessage> {
+    protected history: TMessage[];
+    protected isInitialized: boolean;
+    protected config?: TConfig;
+    /**
+     * Initialize the agent (subclass responsibility)
+     */
+    protected abstract initialize(): Promise<void>;
+    /**
+     * Configure the agent with type-safe configuration
+     */
+    configure(config: TConfig): Promise<void>;
+    /**
+     * Run agent with user input and type-safe context
+     */
+    abstract run(input: string, context?: TContext): Promise<string>;
+    /**
+     * Run agent with streaming response and type-safe context
+     */
+    abstract runStream(input: string, context?: TContext): AsyncGenerator<string, void, never>;
+    /**
+     * Get conversation history with type-safe messages
+     */
+    getHistory(): TMessage[];
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+    /**
+     * Add message to history
+     */
+    protected addMessage(message: TMessage): void;
+    /**
+     * Validate user input
+     */
+    protected validateInput(input: string): void;
+    /**
+     * Ensure agent is initialized before running
+     */
+    protected ensureInitialized(): Promise<void>;
+    /**
+     * Cleanup resources
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=abstract-agent.d.ts.map

package/dist/abstracts/abstract-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-agent.d.ts","sourceRoot":"","sources":["../../src/abstracts/abstract-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEhG,8BAAsB,aAAa,CAC/B,OAAO,GAAG,YAAY,EACtB,QAAQ,GAAG,WAAW,EACtB,QAAQ,GAAG,iBAAiB,CAC9B,YAAW,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;IAC5C,SAAS,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAM;IACnC,SAAS,CAAC,aAAa,UAAS;IAChC,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAE9C;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK/C;;OAEG;IACH,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAEhE;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC;IAE1F;;OAEG;IACH,UAAU,IAAI,QAAQ,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,IAAI;IAIpB;;OAEG;IACH,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAI7C;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C;;OAEG;cACa,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAOlD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAIjC"}

package/dist/abstracts/abstract-agent.js

@@ -0,0 +1,55 @@
+export class AbstractAgent {
+    history = [];
+    isInitialized = false;
+    config;
+    /**
+     * Configure the agent with type-safe configuration
+     */
+    async configure(config) {
+        this.config = config;
+        await this.ensureInitialized();
+    }
+    /**
+     * Get conversation history with type-safe messages
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.history = [];
+    }
+    /**
+     * Add message to history
+     */
+    addMessage(message) {
+        this.history.push(message);
+    }
+    /**
+     * Validate user input
+     */
+    validateInput(input) {
+        if (!input || typeof input !== 'string') {
+            throw new Error('Input must be a non-empty string');
+        }
+    }
+    /**
+     * Ensure agent is initialized before running
+     */
+    async ensureInitialized() {
+        if (!this.isInitialized) {
+            await this.initialize();
+            this.isInitialized = true;
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    async dispose() {
+        this.clearHistory();
+        this.isInitialized = false;
+    }
+}
+//# sourceMappingURL=abstract-agent.js.map

package/dist/abstracts/abstract-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-agent.js","sourceRoot":"","sources":["../../src/abstracts/abstract-agent.ts"],"names":[],"mappings":"AAWA,MAAM,OAAgB,aAAa;IAKrB,OAAO,GAAe,EAAE,CAAC;IACzB,aAAa,GAAG,KAAK,CAAC;IACtB,MAAM,CAAW;IAO3B;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,MAAe;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;IACnC,CAAC;IAYD;;OAEG;IACH,UAAU;QACN,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,YAAY;QACR,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;OAEG;IACO,UAAU,CAAC,OAAiB;QAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;OAEG;IACO,aAAa,CAAC,KAAa;QACjC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;QACxD,CAAC;IACL,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,iBAAiB;QAC7B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9B,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO;QACT,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC/B,CAAC;CACJ"}