Method update

src/memory/context.py:446–554

Update an existing memory system with new configuration and create a new version Args: memory_name: Name of the memory system to update memory: New memory instance or class with updated implementation memory_config_dict: Configuration dict for mem

(self, 
                     memory_name: str,
                     memory: Union[Memory, Type[Memory]],
                     memory_config_dict: Optional[Dict[str, Any]] = None,
                     new_version: Optional[str] = None, 
                     description: Optional[str] = None,
                     code: Optional[str] = None)

            raise
    
    async def update(self, 
                     memory_name: str,
                     memory: Union[Memory, Type[Memory]],
                     memory_config_dict: Optional[Dict[str, Any]] = None,
                     new_version: Optional[str] = None, 
                     description: Optional[str] = None,
                     code: Optional[str] = None) -> MemoryConfig:
        """Update an existing memory system with new configuration and create a new version
        
        Args:
            memory_name: Name of the memory system to update
            memory: New memory instance or class with updated implementation
            memory_config_dict: Configuration dict for memory initialization
                   If None, will try to get from global config
            new_version: New version string. If None, auto-increments from current version.
            description: Description for this version update
            code: Optional source code string. If provided, uses this instead of extracting from memory class.
                  This is useful when memory class is dynamically created from code string.
            
        Returns:
            MemoryConfig: Updated memory configuration
        """
        try:
            # Handle both instance and class cases
            if isinstance(memory, Memory):
                # Updating with an instance
                memory_instance = memory
                memory_cls = type(memory)
                if memory_config_dict:
                    raise ValueError("Extra keyword arguments are not allowed when updating with memory instances.")
                memory_config_dict = {}
            else:
                # Updating with 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 (update 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}")
            
            # Check if memory exists
            original_config = self._memory_configs.get(memory_name)
            if original_config is None:
                raise ValueError(f"Memory {memory_name} not found. Use register() to register a new memory system.")
            
            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
            
            # Determine new version from version_manager
            if new_version is None: