Thank you kindly, Snowdrop, for a patch that solves:

The current API for MRM is quite sparse, this patch 
supplies basic support for accessing the task 
inventory of object.

OpenSim/Region/OptionalModules/Scripting/Minimodule/Interfaces/IAvatar.cs

@@ -50,6 +50,12 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
 		//// <value>
 		/// Array of worn attachments, empty but not null, if no attachments are worn
 		/// </value>
-    	IAvatarAttachment[] Attachments { get; }
+
+		IAvatarAttachment[] Attachments { get; }
+
+		/// <summary>
+		/// Request to open an url clientside
+		/// </summary>
+		void LoadUrl(IObject sender, string message, string url);
     }
 }

OpenSim/Region/OptionalModules/Scripting/Minimodule/Interfaces/IInventoryItem.cs

@@ -0,0 +1,16 @@
+using System;
+using OpenMetaverse;
+
+namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
+{
+	
+	/// <summary>
+	/// This implements the methods needed to operate on individual inventory items.
+	/// </summary>
+	public interface IInventoryItem
+	{
+		int Type { get; }
+		UUID AssetID { get; }
+		T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new();
+	}
+}

OpenSim/Region/OptionalModules/Scripting/Minimodule/Interfaces/IObject.cs

@@ -179,6 +179,10 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
         /// <param name="msg">The message to send to the user</param>
         void Say(string msg);
 
+		//// <value>
+		/// Grants access to the objects inventory
+		/// </value>
+		IObjectInventory Inventory { get; }
     }
 
     public enum PhysicsMaterial

OpenSim/Region/OptionalModules/Scripting/Minimodule/InventoryItem.cs

@@ -0,0 +1,72 @@
+
+using System;
+using System.Text;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+//using OpenSim.Services.AssetService;
+using OpenMetaverse;
+
+namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
+{
+	
+	
+	public class InventoryItem : IInventoryItem
+	{
+		TaskInventoryItem m_privateItem;
+		Scene m_rootSceene;
+		
+		public InventoryItem(Scene rootScene, TaskInventoryItem internalItem)
+		{
+			m_rootSceene = rootScene;
+			m_privateItem = internalItem;
+		}
+
+		// Marked internal, to prevent scripts from accessing the internal type
+		internal TaskInventoryItem ToTaskInventoryItem()
+   		{
+			return m_privateItem;
+		}
+
+		/// <summary>
+		/// This will attempt to convert from an IInventoryItem to an InventoryItem object
+		/// </summary>
+		/// <description>
+		/// In order for this to work the object which implements IInventoryItem must inherit from InventoryItem, otherwise
+		/// an exception is thrown.
+		/// </description>
+		/// <param name="i">
+		/// The interface to upcast <see cref="IInventoryItem"/>
+		/// </param>
+		/// <returns>
+		/// The object backing the interface implementation <see cref="InventoryItem"/>
+		/// </returns>
+		internal static InventoryItem FromInterface(IInventoryItem i)
+   		{
+			if(typeof(InventoryItem).IsAssignableFrom(i.GetType()))
+			{
+				return (InventoryItem)i;
+			}
+			else
+			{
+				throw new ApplicationException("[MRM] There is no legal conversion from IInventoryItem to InventoryItem");
+			}
+		}
+			
+		public int Type { get { return m_privateItem.Type; } }
+		public UUID AssetID { get { return m_privateItem.AssetID; } }
+		
+		public T RetreiveAsset<T>() where T : OpenMetaverse.Asset, new()
+		{
+			AssetBase a = m_rootSceene.AssetService.Get(AssetID.ToString());
+			T result = new T();
+
+			if((sbyte)result.AssetType != a.Type)
+				throw new ApplicationException("[MRM] The supplied asset class does not match the found asset");
+			
+			result.AssetData = a.Data;
+			result.Decode();
+			return result;
+		}
+	}
+}

OpenSim/Region/OptionalModules/Scripting/Minimodule/Object/IObjectInventory.cs

@@ -0,0 +1,17 @@
+
+using System;
+using System.Collections.Generic;
+
+using OpenMetaverse;
+
+namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object
+{
+	
+	/// <summary>
+	/// This implements the methods neccesary to operate on the inventory of an object
+	/// </summary>
+	public interface IObjectInventory : IDictionary<UUID, IInventoryItem>
+	{
+		IInventoryItem this[string name] { get; }
+	}
+}

OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObject.cs

@@ -301,7 +301,12 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
             get { return this; }
         }
 
-        #region Public Functions
+		public IObjectInventory Inventory 
+		{
+			get { return new SOPObjectInventory(m_rootScene, GetSOP().TaskInventory); }
+		}
+		
+		#region Public Functions
 
         public void Say(string msg)
         {

OpenSim/Region/OptionalModules/Scripting/Minimodule/SOPObjectInventory.cs

@@ -0,0 +1,190 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenMetaverse;
+
+namespace OpenSim.Region.OptionalModules.Scripting.Minimodule.Object
+{
+	
+	
+	public class SOPObjectInventory : IObjectInventory
+	{
+		TaskInventoryDictionary m_privateInventory;				/// OpenSim's task inventory
+		Dictionary<UUID, IInventoryItem> m_publicInventory;		/// MRM's inventory
+		Scene m_rootScene;
+
+		public SOPObjectInventory(Scene rootScene, TaskInventoryDictionary taskInventory)
+		{
+			m_rootScene = rootScene;
+			m_privateInventory = taskInventory;
+			m_publicInventory = new Dictionary<UUID, IInventoryItem>();
+		}
+
+		/// <summary>
+		/// Fully populate the public dictionary with the contents of the private dictionary
+		/// </summary>
+		/// <description>
+		/// This will only convert those items which hasn't already been converted. ensuring that
+		/// no items are converted twice, and that any references already in use are maintained.
+		/// </description>
+		private void SynchronizeDictionaries()
+		{
+			foreach(TaskInventoryItem privateItem in m_privateInventory.Values)
+				if(!m_publicInventory.ContainsKey(privateItem.ItemID))
+				   	m_publicInventory.Add(privateItem.ItemID, new InventoryItem(m_rootScene, privateItem));
+		}
+		
+		#region IDictionary<UUID, IInventoryItem> implementation
+		public void Add (UUID key, IInventoryItem value)
+		{
+			m_publicInventory.Add(key, value);
+			m_privateInventory.Add(key, InventoryItem.FromInterface(value).ToTaskInventoryItem());
+		}
+		
+		public bool ContainsKey (UUID key)
+		{
+			return m_privateInventory.ContainsKey(key);
+		}
+		
+		public bool Remove (UUID key)
+		{
+			m_publicInventory.Remove(key);
+			return m_privateInventory.Remove(key);
+		}
+		
+		public bool TryGetValue (UUID key, out IInventoryItem value)
+		{
+			value = null;
+
+			bool result = false;
+			if(!m_publicInventory.TryGetValue(key, out value))
+			{
+				// wasn't found in the public inventory
+				TaskInventoryItem privateItem;
+			
+				result = m_privateInventory.TryGetValue(key, out privateItem);
+				if(result)
+				{
+					value = new InventoryItem(m_rootScene, privateItem);
+					m_publicInventory.Add(key, value);			// add item, so we don't convert again
+				}
+			} else
+				return true;
+			
+			return result;
+		}
+		
+		public ICollection<UUID> Keys {
+			get {
+				return m_privateInventory.Keys;
+			}
+		}
+		
+		public ICollection<IInventoryItem> Values {
+			get {
+				SynchronizeDictionaries();
+				return m_publicInventory.Values;
+			}
+		}
+		#endregion
+
+		#region IEnumerable<KeyValuePair<UUID, IInventoryItem>> implementation
+		public IEnumerator<KeyValuePair<UUID, IInventoryItem>> GetEnumerator ()
+		{
+			SynchronizeDictionaries();
+			return m_publicInventory.GetEnumerator();
+		}
+
+		#endregion
+
+		#region IEnumerable implementation
+		IEnumerator IEnumerable.GetEnumerator ()
+		{
+			SynchronizeDictionaries();
+			return m_publicInventory.GetEnumerator();
+		}
+
+		#endregion
+
+		#region ICollection<KeyValuePair<UUID, IInventoryItem>> implementation
+		public void Add (KeyValuePair<UUID, IInventoryItem> item)
+		{
+			Add(item.Key, item.Value);
+		}
+		
+		public void Clear ()
+		{
+			m_publicInventory.Clear();
+			m_privateInventory.Clear();
+		}
+		
+		public bool Contains (KeyValuePair<UUID, IInventoryItem> item)
+		{
+			return m_privateInventory.ContainsKey(item.Key);
+		}
+		
+		public void CopyTo (KeyValuePair<UUID, IInventoryItem>[] array, int arrayIndex)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public bool Remove (KeyValuePair<UUID, IInventoryItem> item)
+		{
+			return Remove(item.Key);
+		}
+		
+		public int Count {
+			get {
+				return m_privateInventory.Count;
+			}
+		}
+		
+		public bool IsReadOnly {
+			get {
+				return false;
+			}
+		}
+		#endregion
+		
+		#region Explicit implementations
+		IInventoryItem System.Collections.Generic.IDictionary<UUID, IInventoryItem>.this[UUID key]
+		{
+			get {
+				IInventoryItem result;
+				if(TryGetValue(key, out result))
+				   return result;
+				else
+					throw new KeyNotFoundException("[MRM] The requrested item ID could not be found");
+			}
+			set {
+				m_publicInventory[key] = value;
+				m_privateInventory[key] = InventoryItem.FromInterface(value).ToTaskInventoryItem();
+			}
+		}
+				
+		void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<UUID, IInventoryItem>>.CopyTo(System.Collections.Generic.KeyValuePair<UUID,IInventoryItem>[] array, int offset)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+		
+		public IInventoryItem this[string name]
+		{
+			get {
+				foreach(TaskInventoryItem i in m_privateInventory.Values)
+					if(i.Name == name)
+					{
+						if(!m_publicInventory.ContainsKey(i.ItemID))
+							m_publicInventory.Add(i.ItemID, new InventoryItem(m_rootScene, i));
+					
+						return m_publicInventory[i.ItemID];
+					}
+				throw new KeyNotFoundException();
+			}
+		}
+
+	}
+}

OpenSim/Region/OptionalModules/Scripting/Minimodule/SPAvatar.cs

@@ -32,6 +32,7 @@ using System.Collections.Generic;
 
 using OpenMetaverse;
 using OpenSim.Region.Framework.Scenes;
+using OpenSim.Region.Framework.Interfaces;
 
 using log4net;
 
@@ -90,6 +91,13 @@ namespace OpenSim.Region.OptionalModules.Scripting.Minimodule
 				return attachments.ToArray();
 			}
 		}
+
+		public void LoadUrl(IObject sender, string message, string url)
+		{
+			IDialogModule dm = m_rootScene.RequestModuleInterface<IDialogModule>();
+			if(dm != null)
+				dm.SendUrlToUser(GetSP().UUID, sender.Name, sender.GlobalID, GetSP().UUID, false, message, url);
+		}
 		#endregion
     }
 }