Method register

src/memory/context.py:340–444

Register a memory class or instance. This will: - Create (or reuse) a memory instance - Create a `MemoryConfig` - Store it as the current config and append to version history - Register the version in `version_manager` Args:

(self, 
                       memory: Union[Memory, Type[Memory]],
                       memory_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None)

        return memory_configs
    
    async def register(self, 
                       memory: Union[Memory, Type[Memory]],
                       memory_config_dict: Optional[Dict[str, Any]] = None,
                       override: bool = False,
                       version: Optional[str] = None) -> MemoryConfig:
        """Register a memory class or instance.
        
        This will:
        - Create (or reuse) a memory instance
        - Create a `MemoryConfig`
        - Store it as the current config and append to version history
        - Register the version in `version_manager`
        
        Args:
            memory: Memory instance or class
            memory_config_dict: Configuration dict for memory initialization (required when memory is a class)
            override: Whether to override existing registration
            version: Optional version string
            
        Returns:
            MemoryConfig: Memory configuration
        """
        
        try:
            # Handle both instance and class cases
            if isinstance(memory, Memory):
                # Registering an instance
                memory_instance = memory
                memory_cls = type(memory)
                if memory_config_dict:
                    raise ValueError("Extra keyword arguments are not allowed when registering memory instances.")
                memory_config_dict = {}
            else:
                # Registering a class
                memory_cls = memory
                if memory_config_dict is None:
                    # Fallback to global config by class name
                    memory_config_key = inflection.underscore(memory_cls.__name__)
                    memory_config_dict = config.get(memory_config_key, {})
                
                # Instantiate memory immediately (register is a runtime operation)
                try:
                    memory_instance = memory_cls(**memory_config_dict)
                except Exception as e:
                    logger.error(f"| ❌ Failed to create memory instance for {memory_cls.__name__}: {e}")
                    raise ValueError(f"Failed to instantiate memory {memory_cls.__name__} with provided config: {e}")
            
            memory_name = memory_instance.name
            memory_description = memory_instance.description
            memory_metadata = getattr(memory_instance, 'metadata', {})
            # Get require_grad from memory_config_dict if provided, otherwise from memory_instance
            memory_require_grad = memory_config_dict.get("require_grad", memory_instance.require_grad) if memory_config_dict and "require_grad" in memory_config_dict else memory_instance.require_grad
            
            if not memory_name:
                raise ValueError("Memory.name cannot be empty.")
            
            if memory_name in self._memory_configs and not override:
                raise ValueError(f"Memory '{memory_name}' already registered. Use override=True to replace it.")