More JVoiceXML integration

18 files changed, 1175 insertions, 397 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c948689..9809bcc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -687,10 +687,26 @@ if (APPLE OR IOS)
 
 endif()
 
+OPTION(DISABLE_SPIDERMONKEY "Ignore SpiderMonkey" ON)
+if (NOT DISABLE_SPIDERMONKEY AND NOT DISABLE_ALL AND NOT ECMA_FOUND)
+	find_package(SpiderMonkey)
+	if (SPIDERMONKEY_FOUND)
+		set(ECMA_FOUND ON)
+		include_directories(${SPIDERMONKEY_INCLUDE_DIR})
+		if (UNIX)
+			add_definitions(-DXP_UNIX)
+		endif()
+		list (APPEND USCXML_OPT_LIBS ${SPIDERMONKEY_LIBRARY})
+	endif()
+else()
+	set(SPIDERMONKEY_FOUND OFF)
+endif()
+
 OPTION(DISABLE_JSC "Ignore JavaScriptCore" OFF)
-if (NOT DISABLE_JSC AND NOT DISABLE_ALL AND NOT V8_FOUND)
+if (NOT DISABLE_JSC AND NOT DISABLE_ALL AND NOT ECMA_FOUND)
 	find_package(JSC)
 	if (JSC_FOUND)
+		set(ECMA_FOUND ON)
 		if (NOT APPLE)
 			include_directories(${JSC_INCLUDE_DIR})
 		endif()
@@ -701,9 +717,10 @@ else()
 endif()
 
 OPTION(DISABLE_V8 "Ignore Google's v8" OFF)
-if (NOT DISABLE_V8 AND NOT DISABLE_ALL AND NOT JSC_FOUND)
+if (NOT DISABLE_V8 AND NOT DISABLE_ALL AND NOT ECMA_FOUND)
 	find_package(V8)
 	if (V8_FOUND)
+		set(ECMA_FOUND ON)
 		include_directories(${V8_INCLUDE_DIR})
 		list (APPEND USCXML_OPT_LIBS ${V8_LIBRARY})
 	endif()
diff --git a/contrib/cmake/FindSpiderMonkey.cmake b/contrib/cmake/FindSpiderMonkey.cmake
new file mode 100644
index 0000000..0c61be7
--- /dev/null
+++ b/contrib/cmake/FindSpiderMonkey.cmake
@@ -0,0 +1,25 @@
+FIND_PATH(SPIDERMONKEY_INCLUDE_DIR jsapi.h
+  PATH_SUFFIXES include/js
+  PATHS
+  /usr/local
+  /usr
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+FIND_LIBRARY(SPIDERMONKEY_LIBRARY NAMES js
+  PATH_SUFFIXES lib
+  PATHS
+  /usr/local
+  /usr
+  /sw # Fink
+  /opt/local # DarwinPorts
+  /opt/csw # Blastwave
+  /opt
+)
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SPIDERMONKEY DEFAULT_MSG SPIDERMONKEY_LIBRARY SPIDERMONKEY_INCLUDE_DIR)
+MARK_AS_ADVANCED(JSC_LIBRARY JSC_INCLUDE_DIR)
diff --git a/src/uscxml/URL.cpp b/src/uscxml/URL.cpp
index f5ba85c..b245149 100644
--- a/src/uscxml/URL.cpp
+++ b/src/uscxml/URL.cpp
@@ -565,6 +565,12 @@ void URLFetcher::fetchURL(URL& url) {
 //		(curlError = curl_easy_setopt(handle, CURLOPT_NOSIGNAL, 1)) == CURLE_OK ||
 //		LOG(ERROR) << "Cannot set curl to ignore signals: " << curl_easy_strerror(curlError);
 
+//		(curlError = curl_easy_setopt(handle, CURLOPT_FORBID_REUSE, 1)) == CURLE_OK ||
+//		LOG(ERROR) << "Cannot force noreuse: " << curl_easy_strerror(curlError);
+
+		(curlError = curl_easy_setopt(handle, CURLOPT_VERBOSE, 1)) == CURLE_OK ||
+		LOG(ERROR) << "Cannot set verbose: " << curl_easy_strerror(curlError);
+
 		(curlError = curl_easy_setopt(handle, CURLOPT_WRITEDATA, url._impl.get())) == CURLE_OK ||
 		LOG(ERROR) << "Cannot register this as write userdata: " << curl_easy_strerror(curlError);
 
@@ -580,7 +586,7 @@ void URLFetcher::fetchURL(URL& url) {
 		(curlError = curl_easy_setopt(handle, CURLOPT_SSL_VERIFYPEER, false)) == CURLE_OK ||
 		LOG(ERROR) << "Cannot forfeit peer verification: " << curl_easy_strerror(curlError);
 
-		(curlError = curl_easy_setopt(handle, CURLOPT_USERAGENT, "curl/7.31.0")) == CURLE_OK ||
+		(curlError = curl_easy_setopt(handle, CURLOPT_USERAGENT, "uscxml/0.3.3")) == CURLE_OK ||
 		LOG(ERROR) << "Cannot set our user agent string: " << curl_easy_strerror(curlError);
 
 		(curlError = curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, true)) == CURLE_OK ||
diff --git a/src/uscxml/messages/Event.cpp b/src/uscxml/messages/Event.cpp
index 43c6600..fda24dd 100644
--- a/src/uscxml/messages/Event.cpp
+++ b/src/uscxml/messages/Event.cpp
@@ -72,29 +72,6 @@ Arabica::DOM::Document<std::string> Event::toDocument() {
 	return document;
 }
 
-void Event::initContent(const std::string& content) {
-	// try to parse as JSON
-	Data json = Data::fromJSON(content);
-	if (!json.empty()) {
-		data = json;
-		return;
-	}
-
-	// try to parse as XML
-	Arabica::SAX2DOM::Parser<std::string> parser;
-	Arabica::SAX::CatchErrorHandler<std::string> errorHandler;
-	parser.setErrorHandler(errorHandler);
-
-	std::istringstream is(content);
-	Arabica::SAX::InputSource<std::string> inputSource;
-	inputSource.setByteStream(is);
-	if (parser.parse(inputSource)) {
-		dom = parser.getDocument();
-		return;
-	}
-
-	this->content = content;
-}
 
 Event Event::fromXML(const std::string& xmlString) {
 	Arabica::SAX2DOM::Parser<std::string> eventParser;
diff --git a/src/uscxml/messages/Event.h b/src/uscxml/messages/Event.h
index a63c55f..d282fc2 100644
--- a/src/uscxml/messages/Event.h
+++ b/src/uscxml/messages/Event.h
@@ -182,8 +182,6 @@ public:
 		this->data = data;
 	}
 
-	void initContent(const std::string& content);
-
 	static Event fromXML(const std::string& xmlString);
 	Arabica::DOM::Document<std::string> toDocument();
 	std::string toXMLString();
diff --git a/src/uscxml/messages/MMIMessages.cpp b/src/uscxml/messages/MMIMessages.cpp
index 01705ed..dffda5b 100644
--- a/src/uscxml/messages/MMIMessages.cpp
+++ b/src/uscxml/messages/MMIMessages.cpp
@@ -28,6 +28,30 @@
 
 #include <boost/algorithm/string.hpp>
 
+#define TO_EVENT_OPERATOR(type, name, base)\
+type::operator Event() const { \
+	Event ev = base::operator Event();\
+	ev.setName(name);\
+	if (representation == MMI_AS_XML) \
+		ev.setDOM(toXML());\
+	return ev;\
+}
+
+#define FIND_MSG_ELEM(elem, doc) \
+Element<std::string> elem; \
+if (encapsulateInMMI) { \
+	elem = Element<std::string>(doc.getDocumentElement().getFirstChild()); \
+} else { \
+	elem = Element<std::string>(doc.getDocumentElement()); \
+}
+
+#define FROM_XML(clazz, enumType, base) \
+clazz clazz::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) { \
+	clazz event = base::fromXML(node, interpreter); \
+	event.type = enumType; \
+	return event; \
+}
+
 #define STRING_ATTR_OR_EXPR(element, name)\
 (element.hasAttributeNS(nameSpace, "name##Expr") && interpreter ? \
 	interpreter->getDataModel().evalAsString(element.getAttributeNS(nameSpace, "name##Expr")) : \
@@ -35,6 +59,8 @@
 )
 
 #define FIND_EVENT_NODE(node)\
+if (node.getNodeType() == Node_base::DOCUMENT_NODE) \
+	node = node.getFirstChild(); \
 while (node) {\
 	if (node.getNodeType() == Node_base::ELEMENT_NODE) {\
 		if (boost::iequals(node.getLocalName(), "MMI")) {\
@@ -117,16 +143,16 @@ Arabica::DOM::Document<std::string> MMIEvent::toXML(bool encapsulateInMMI) const
 	msgElem.setAttributeNS(nameSpace, "Target", target);
 	msgElem.setAttributeNS(nameSpace, "RequestID", requestId);
 
-	if (data.size() > 0) {
-		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
-		Text<std::string> textElem = doc.createTextNode(data);
-		dataElem.appendChild(textElem);
-		msgElem.appendChild(dataElem);
-	} else if (dataDOM) {
+	if (dataDOM) {
 		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
 		Node<std::string> importNode = doc.importNode(dataDOM, true);
 		dataElem.appendChild(importNode);
 		msgElem.appendChild(dataElem);
+	}	else if (data.size() > 0) {
+		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
+		Text<std::string> textElem = doc.createTextNode(data);
+		dataElem.appendChild(textElem);
+		msgElem.appendChild(dataElem);
 	}
 
 	if (encapsulateInMMI) {
@@ -139,16 +165,9 @@ Arabica::DOM::Document<std::string> MMIEvent::toXML(bool encapsulateInMMI) const
 	return doc;
 }
 
-Arabica::DOM::Document<std::string> ContextualizedRequest::toXML(bool encapsulateInMMI) const {
-	Document<std::string> doc = MMIEvent::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
-	msgElem.setAttributeNS(nameSpace, "Context", context);
-	return doc;
-}
-
 Arabica::DOM::Document<std::string> ContentRequest::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	if (contentURL.href.size() > 0) {
 		Element<std::string> contentURLElem = doc.createElementNS(nameSpace, "ContentURL");
@@ -170,16 +189,23 @@ Arabica::DOM::Document<std::string> ContentRequest::toXML(bool encapsulateInMMI)
 	return doc;
 }
 
+Arabica::DOM::Document<std::string> ContextualizedRequest::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = MMIEvent::toXML(encapsulateInMMI);
+	FIND_MSG_ELEM(msgElem, doc);
+	msgElem.setAttributeNS(nameSpace, "Context", context);
+	return doc;
+}
+
 Arabica::DOM::Document<std::string> ExtensionNotification::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 	msgElem.setAttributeNS(nameSpace, "Name", name);
 	return doc;
 }
 
 Arabica::DOM::Document<std::string> StatusResponse::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 	if (status == ALIVE) {
 		msgElem.setAttributeNS(nameSpace, "Status", "alive");
 	} else if(status == DEAD) {
@@ -194,7 +220,7 @@ Arabica::DOM::Document<std::string> StatusResponse::toXML(bool encapsulateInMMI)
 
 Arabica::DOM::Document<std::string> StatusInfoResponse::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = StatusResponse::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	Element<std::string> statusInfoElem = doc.createElementNS(nameSpace, "StatusInfo");
 	Text<std::string> statusInfoText = doc.createTextNode(statusInfo);
@@ -206,7 +232,7 @@ Arabica::DOM::Document<std::string> StatusInfoResponse::toXML(bool encapsulateIn
 
 Arabica::DOM::Document<std::string> StatusRequest::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	if (automaticUpdate) {
 		msgElem.setAttributeNS(nameSpace, "RequestAutomaticUpdate", "true");
@@ -217,18 +243,22 @@ Arabica::DOM::Document<std::string> StatusRequest::toXML(bool encapsulateInMMI)
 	return doc;
 }
 
+	
+
 MMIEvent MMIEvent::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	MMIEvent msg;
+
 	FIND_EVENT_NODE(node);
 
 	Element<std::string> msgElem(node);
 	msg.source = STRING_ATTR_OR_EXPR(msgElem, Source);
 	msg.target = STRING_ATTR_OR_EXPR(msgElem, Target);
-//	msg.data = STRING_ATTR_OR_EXPR(msgElem, Data);
 	msg.requestId = STRING_ATTR_OR_EXPR(msgElem, RequestID);
 	msg.tagName = msgElem.getLocalName();
 
 	Element<std::string> dataElem;
+	
+	// search for data element
 	node = msgElem.getFirstChild();
 	while (node) {
 		if (node.getNodeType() == Node_base::ELEMENT_NODE)
@@ -239,47 +269,60 @@ MMIEvent MMIEvent::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl
 	}
 
 	if (dataElem && boost::iequals(dataElem.getLocalName(), "data") && dataElem.getFirstChild()) {
-		node = dataElem.getFirstChild();
-		if (node.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE) {
-			msg.dataDOM = node;
-		} else {
-			std::stringstream ss;
-			ss << node;
-			msg.data = ss.str();
+		Arabica::DOM::Node<std::string> dataChild = dataElem.getFirstChild();
+		std::stringstream ss;
+
+		while (dataChild) {
+			if (dataChild.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE)
+				msg.dataDOM = dataChild;
+			ss << dataChild;
+			dataChild = dataChild.getNextSibling();
 		}
+		msg.data = ss.str();
 	}
 
 	return msg;
 }
 
-MMIEvent::operator Event() const {
-	Event ev;
-	ev.setOriginType("mmi.event");
-	ev.setOrigin(source);
-	ev.setRaw(data);
-	ev.setSendId(requestId);
-	if (data.length() > 0) {
-		ev.initContent(data);
-	}
-	return ev;
-}
+FROM_XML(NewContextRequest,    NEWCONTEXTREQUEST,    MMIEvent)
+
+FROM_XML(PauseRequest,         PAUSEREQUEST,         ContextualizedRequest)
+FROM_XML(ResumeRequest,        RESUMEREQUEST,        ContextualizedRequest)
+FROM_XML(ClearContextRequest,  CLEARCONTEXTREQUEST,  ContextualizedRequest)
+FROM_XML(CancelRequest,        CANCELREQUEST,        ContextualizedRequest)
+
+FROM_XML(PrepareRequest,       PREPAREREQUEST,       ContentRequest)
+FROM_XML(StartRequest,         STARTREQUEST,         ContentRequest)
+
+FROM_XML(PrepareResponse,      PREPARERESPONSE,      StatusInfoResponse)
+FROM_XML(StartResponse,        STARTRESPONSE,        StatusInfoResponse)
+FROM_XML(CancelResponse,       CANCELRESPONSE,       StatusInfoResponse)
+FROM_XML(PauseResponse,        PAUSERESPONSE,        StatusInfoResponse)
+FROM_XML(ResumeResponse,       RESUMERESPONSE,       StatusInfoResponse)
+FROM_XML(ClearContextResponse, CLEARCONTEXTRESPONSE, StatusInfoResponse)
+FROM_XML(NewContextResponse,   NEWCONTEXTRESPONSE,   StatusInfoResponse)
+FROM_XML(DoneNotification,     DONENOTIFICATION,     StatusInfoResponse)
+
 
 ContextualizedRequest ContextualizedRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	ContextualizedRequest msg(MMIEvent::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
-
+	
 	Element<std::string> msgElem(node);
 	msg.context = STRING_ATTR_OR_EXPR(msgElem, Context);
 	return msg;
 }
 
-ContextualizedRequest::operator Event() const {
-	Event ev = MMIEvent::operator Event();
-	// do we want to represent the context? It's the interpreters name already
-	return ev;
+ExtensionNotification ExtensionNotification::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	ExtensionNotification msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+	
+	Element<std::string> msgElem(node);
+	msg.name = STRING_ATTR_OR_EXPR(msgElem, Name);
+	msg.type = EXTENSIONNOTIFICATION;
+	return msg;
 }
 
-
 ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	ContentRequest msg(ContextualizedRequest::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
@@ -300,16 +343,17 @@ ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, Int
 
 	if (contentElem) {
 		if(boost::iequals(contentElem.getLocalName(), "content")) {
+			Arabica::DOM::Node<std::string> contentChild = contentElem.getFirstChild();
 			std::stringstream ss;
-			node = contentElem.getFirstChild();
-			while (node) {
-				if (node.getNodeType() == Node_base::ELEMENT_NODE) {
-					ss << node;
-					break;
-				}
-				node = node.getNextSibling();
+			
+			while (contentChild) {
+				if (contentChild.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE)
+					msg.contentDOM = contentChild;
+				ss << contentChild;
+				contentChild = contentChild.getNextSibling();
 			}
 			msg.content = ss.str();
+			
 		} else if(boost::iequals(contentElem.getLocalName(), "contentURL")) {
 			msg.contentURL.href = STRING_ATTR_OR_EXPR(contentElem, href);
 			msg.contentURL.maxAge = STRING_ATTR_OR_EXPR(contentElem, max-age);
@@ -321,26 +365,6 @@ ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, Int
 	return msg;
 }
 
-ExtensionNotification ExtensionNotification::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
-	ExtensionNotification msg(ContextualizedRequest::fromXML(node, interpreter));
-	FIND_EVENT_NODE(node);
-
-	Element<std::string> msgElem(node);
-	msg.name = STRING_ATTR_OR_EXPR(msgElem, Name);
-	msg.type = EXTENSIONNOTIFICATION;
-	return msg;
-}
-
-ExtensionNotification::operator Event() const {
-	Event ev = ContextualizedRequest::operator Event();
-	if (name.length() > 0) {
-		ev.setName("mmi.extensionnotification." + name);
-	} else {
-		ev.setName("mmi.extensionnotification");
-	}
-	return ev;
-}
-
 StatusResponse StatusResponse::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	StatusResponse msg(ContextualizedRequest::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
@@ -416,5 +440,108 @@ StatusRequest StatusRequest::fromXML(Arabica::DOM::Node<std::string> node, Inter
 	return msg;
 }
 
+	
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	
+	TO_EVENT_OPERATOR(NewContextRequest,    "mmi.request.newcontext",    MMIEvent);
+	TO_EVENT_OPERATOR(PauseRequest,         "mmi.request.pause",         ContextualizedRequest);
+	TO_EVENT_OPERATOR(ResumeRequest,        "mmi.request.resume",        ContextualizedRequest);
+	TO_EVENT_OPERATOR(CancelRequest,        "mmi.request.cancel",        ContextualizedRequest);
+	TO_EVENT_OPERATOR(ClearContextRequest,  "mmi.request.clearcontext",  ContextualizedRequest);
+	TO_EVENT_OPERATOR(StatusRequest,        "mmi.request.status",        ContextualizedRequest);
+	
+	TO_EVENT_OPERATOR(PrepareRequest,       "mmi.request.prepare",       ContentRequest);
+	TO_EVENT_OPERATOR(StartRequest,         "mmi.request.start",         ContentRequest);
+	
+	TO_EVENT_OPERATOR(PrepareResponse,      "mmi.response.prepare",      StatusInfoResponse);
+	TO_EVENT_OPERATOR(StartResponse,        "mmi.response.start",        StatusInfoResponse);
+	TO_EVENT_OPERATOR(CancelResponse,       "mmi.response.cancel",       StatusInfoResponse);
+	TO_EVENT_OPERATOR(PauseResponse,        "mmi.response.pause",        StatusInfoResponse);
+	TO_EVENT_OPERATOR(ResumeResponse,       "mmi.response.resume",       StatusInfoResponse);
+	TO_EVENT_OPERATOR(ClearContextResponse, "mmi.response.clearcontext", StatusInfoResponse);
+	TO_EVENT_OPERATOR(NewContextResponse,   "mmi.response.newcontext",   StatusInfoResponse);
+	TO_EVENT_OPERATOR(DoneNotification,     "mmi.notification.done",     StatusInfoResponse);
+
+	
+	MMIEvent::operator Event() const {
+		Event ev;
+		ev.setOriginType("mmi.event");
+		ev.setOrigin(source);
+		
+		if (representation == MMI_AS_DATA) {
+			if (dataDOM) {
+				ev.data.node = dataDOM;
+			} else {
+				ev.data = Data::fromJSON(data);
+				if (ev.data.empty()) {
+					ev.content = data;
+				}
+			}
+		}
+		return ev;
+	}
+	
+	ContextualizedRequest::operator Event() const {
+		Event ev = MMIEvent::operator Event();
+		// do we want to represent the context? It's the interpreters name already
+		return ev;
+	}
+
+	ExtensionNotification::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		if (name.length() > 0) {
+			ev.setName(name);
+		} else {
+			ev.setName("mmi.notification.extension");
+		}
+		return ev;
+	}
+
+	ContentRequest::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		if (representation == MMI_AS_DATA) {
+			if (content.length() > 0)
+				ev.data.compound["content"] = Data(content, Data::VERBATIM);
+			if (contentURL.fetchTimeout.length() > 0)
+				ev.data.compound["contentURL"].compound["fetchTimeout"] = Data(contentURL.fetchTimeout, Data::VERBATIM);
+			if (contentURL.href.length() > 0)
+				ev.data.compound["contentURL"].compound["href"] = Data(contentURL.href, Data::VERBATIM);
+			if (contentURL.maxAge.length() > 0)
+				ev.data.compound["contentURL"].compound["maxAge"] = Data(contentURL.maxAge, Data::VERBATIM);
+		}
+		return ev;
+	}
+
+	StatusResponse::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setName("mmi.response.status");
+
+		if (representation == MMI_AS_DATA) {
+			switch (status) {
+				case ALIVE:
+					ev.data.compound["status"] = Data("alive", Data::VERBATIM);
+					break;
+				case DEAD:
+					ev.data.compound["status"] = Data("dead", Data::VERBATIM);
+					break;
+				case SUCCESS:
+					ev.data.compound["status"] = Data("success", Data::VERBATIM);
+					break;
+				case FAILURE:
+					ev.data.compound["status"] = Data("failure", Data::VERBATIM);
+					break;
+				default:
+					ev.data.compound["status"] = Data("invalid", Data::VERBATIM);
+			}
+		} else {
+			ev.dom = toXML();
+		}
+		
+		return ev;
+	}
+
+#endif
+
 
 }
\ No newline at end of file
diff --git a/src/uscxml/messages/MMIMessages.h b/src/uscxml/messages/MMIMessages.h
index c6a2fce..2cffa0f 100644
--- a/src/uscxml/messages/MMIMessages.h
+++ b/src/uscxml/messages/MMIMessages.h
@@ -20,6 +20,8 @@
 #ifndef MMIEVENT_H_OS0SE7H5
 #define MMIEVENT_H_OS0SE7H5
 
+#define MMI_WITH_OPERATOR_EVENT 1
+
 #include <DOM/Node.hpp>
 #include <DOM/Document.hpp>
 #include <uscxml/Interpreter.h>
@@ -50,37 +52,34 @@ public:
 		INVALID
 	};
 
+	enum RepresentationType {
+		MMI_AS_DATA,
+		MMI_AS_XML
+	};
 	static Type getType(Arabica::DOM::Node<std::string> node);
 
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static MMIEvent fromXML(Arabica::DOM::Node<std::string> node,
-	                        InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static MMIEvent fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
 	// conversion operator
 	operator Event() const;
-
+#endif
+	
 	std::string source;
 	std::string target;
 	std::string data;
 	Arabica::DOM::Node<std::string> dataDOM;
 	std::string requestId;
+	
 	std::string tagName;
 	Type type;
-
+	RepresentationType representation;
+	
 	static std::string nameSpace;
 
 protected:
-	MMIEvent() {}
-};
-
-class MMIEventReceiver {
-public:
-	virtual void received(const MMIEvent& mmiEvent) = 0;
-};
-
-class MMIEventSender {
-public:
-	virtual void send(const MMIEvent& mmiEvent) = 0;
+	MMIEvent() : representation(MMI_AS_DATA) {}
 };
 
 class NewContextRequest : public MMIEvent {
@@ -90,27 +89,24 @@ public:
 		type = NEWCONTEXTREQUEST;
 	}
 	NewContextRequest(const MMIEvent& father) : MMIEvent(father) {}
-	static NewContextRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                 InterpreterImpl* interpreter = NULL) {
-		MMIEvent event = MMIEvent::fromXML(node, interpreter);
-		event.type = NEWCONTEXTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = MMIEvent::operator Event();
-		ev.setName("mmi.newcontextrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static NewContextRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 	std::string token; ///< special token for server-less modality components
 };
 
 class ContextualizedRequest : public MMIEvent {
 public:
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ContextualizedRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                     InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ContextualizedRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string context;
 protected:
 	ContextualizedRequest() {}
@@ -124,19 +120,12 @@ public:
 		type = PAUSEREQUEST;
 	}
 	PauseRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static PauseRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                            InterpreterImpl* interpreter = NULL) {
-		PauseRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = PAUSEREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.pauserequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
-
+	static PauseRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class ResumeRequest : public ContextualizedRequest {
 public:
@@ -145,19 +134,12 @@ public:
 		type = RESUMEREQUEST;
 	}
 	ResumeRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static ResumeRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		ResumeRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = RESUMEREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setDOM(toXML());
-		ev.setName("mmi.resumerequest");
-		return ev;
-	}
-
+	static ResumeRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class CancelRequest : public ContextualizedRequest {
 public:
@@ -166,18 +148,11 @@ public:
 		type = CANCELREQUEST;
 	}
 	CancelRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static CancelRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		CancelRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = CANCELREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.cancelrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static CancelRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 
 };
 class ClearContextRequest : public ContextualizedRequest {
@@ -187,19 +162,12 @@ public:
 		type = CLEARCONTEXTREQUEST;
 	}
 	ClearContextRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static ClearContextRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                   InterpreterImpl* interpreter = NULL) {
-		ClearContextRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = CLEARCONTEXTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.clearcontextrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ClearContextRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class StatusRequest : public ContextualizedRequest {
 public:
@@ -207,10 +175,13 @@ public:
 		tagName = "StatusRequest";
 		type = STARTREQUEST;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static StatusRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static StatusRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	bool automaticUpdate;
 protected:
 	StatusRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -224,10 +195,13 @@ public:
 		std::string fetchTimeout;
 	};
 
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ContentRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ContentRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string content;
 	Arabica::DOM::Node<std::string> contentDOM;
 	ContentURL contentURL;
@@ -243,18 +217,11 @@ public:
 		type = PREPAREREQUEST;
 	}
 	PrepareRequest(const ContentRequest& father) : ContentRequest(father) {}
-	static PrepareRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		PrepareRequest event = ContentRequest::fromXML(node, interpreter);
-		event.type = PREPAREREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContentRequest::operator Event();
-		ev.setName("mmi.preparerequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PrepareRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class StartRequest : public ContentRequest {
@@ -264,18 +231,11 @@ public:
 		type = STARTREQUEST;
 	}
 	StartRequest(const ContentRequest& father) : ContentRequest(father) {}
-	static StartRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                            InterpreterImpl* interpreter = NULL) {
-		StartRequest event = ContentRequest::fromXML(node, interpreter);
-		event.type = STARTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContentRequest::operator Event();
-		ev.setName("mmi.startrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static StartRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 
 };
 
@@ -285,10 +245,13 @@ public:
 		tagName = "ExtensionNotification";
 		type = EXTENSIONNOTIFICATION;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ExtensionNotification fromXML(Arabica::DOM::Node<std::string> node,
-	                                     InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ExtensionNotification fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string name;
 protected:
 	ExtensionNotification(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -310,9 +273,13 @@ public:
 		type = STATUSRESPONSE;
 		status = INVALID;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static StatusResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static StatusResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+
 	Status status;
 protected:
 	StatusResponse(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -320,10 +287,9 @@ protected:
 
 class StatusInfoResponse : public StatusResponse {
 public:
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
 	StatusInfoResponse(const StatusResponse& father) : StatusResponse(father) {}
-	static StatusInfoResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                  InterpreterImpl* interpreter = NULL);
+	static StatusInfoResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 	std::string statusInfo;
 protected:
 	StatusInfoResponse() {}
@@ -336,18 +302,12 @@ public:
 		type = PREPARERESPONSE;
 	}
 	PrepareResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static PrepareResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                               InterpreterImpl* interpreter = NULL) {
-		PrepareResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = PREPARERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.prepareresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PrepareResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 
 class StartResponse : public StatusInfoResponse {
@@ -357,18 +317,11 @@ public:
 		type = STARTRESPONSE;
 	}
 	StartResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static StartResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		StartResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = STARTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.startresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static StartResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class CancelResponse : public StatusInfoResponse {
@@ -378,18 +331,11 @@ public:
 		type = CANCELRESPONSE;
 	}
 	CancelResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static CancelResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		CancelResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = CANCELRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.cancelresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static CancelResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class PauseResponse : public StatusInfoResponse {
@@ -399,18 +345,11 @@ public:
 		type = PAUSERESPONSE;
 	}
 	PauseResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static PauseResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		PauseResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = PAUSERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.pauseresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PauseResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class ResumeResponse : public StatusInfoResponse {
@@ -420,18 +359,11 @@ public:
 		type = RESUMERESPONSE;
 	}
 	ResumeResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static ResumeResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		ResumeResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = RESUMERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.resumeresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ResumeResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class ClearContextResponse : public StatusInfoResponse {
@@ -441,18 +373,11 @@ public:
 		type = CLEARCONTEXTRESPONSE;
 	}
 	ClearContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static ClearContextResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                    InterpreterImpl* interpreter = NULL) {
-		ClearContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = CLEARCONTEXTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.clearcontextresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ClearContextResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class NewContextResponse : public StatusInfoResponse {
@@ -462,19 +387,11 @@ public:
 		type = NEWCONTEXTRESPONSE;
 	}
 	NewContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static NewContextResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                  InterpreterImpl* interpreter = NULL) {
-		NewContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = NEWCONTEXTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.newcontextresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static NewContextResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class DoneNotification : public StatusInfoResponse {
@@ -484,18 +401,11 @@ public:
 		type = DONENOTIFICATION;
 	}
 	DoneNotification(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static DoneNotification fromXML(Arabica::DOM::Node<std::string> node,
-	                                InterpreterImpl* interpreter = NULL) {
-		DoneNotification event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = DONENOTIFICATION;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.donenotification");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static DoneNotification fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 }
diff --git a/src/uscxml/plugins/datamodel/CMakeLists.txt b/src/uscxml/plugins/datamodel/CMakeLists.txt
index 76f928b..2570dda 100644
--- a/src/uscxml/plugins/datamodel/CMakeLists.txt
+++ b/src/uscxml/plugins/datamodel/CMakeLists.txt
@@ -66,6 +66,30 @@ if (BUILD_DM_ECMA)
 				list (APPEND USCXML_FILES ${V8_DOM})
 			endif()
 		endif()
+	elseif(SPIDERMONKEY_FOUND)
+		set(USCXML_DATAMODELS "ecmascript(SpiderMonkey) ${USCXML_DATAMODELS}")
+		# set(ENV{V8_SRC} ${CMAKE_SOURCE_DIR}/../v8)
+		file(GLOB SPIDERMONKEY_DATAMODEL
+			ecmascript/SpiderMonkey/*.cpp
+			ecmascript/SpiderMonkey/*.h
+			ecmascript/*.cpp
+			ecmascript/*.h
+		)
+
+		if (BUILD_AS_PLUGINS)
+			source_group("SpiderMonkey" FILES ${SPIDERMONKEY_DATAMODEL})
+
+			add_library(
+				datamodel_spidermonkey SHARED 
+				${SPIDERMONKEY_DATAMODEL}
+			"../Plugins.cpp")
+			target_link_libraries(datamodel_spidermonkey uscxml ${SPIDERMONKEY_LIBRARY})
+			set_target_properties(datamodel_spidermonkey PROPERTIES FOLDER "Plugin DataModel")
+			set_target_properties(datamodel_spidermonkey PROPERTIES COMPILE_FLAGS "-DPLUMA_EXPORTS")
+			set_target_properties(datamodel_spidermonkey PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_DIR}/lib")
+		else()
+			list (APPEND USCXML_FILES ${SPIDERMONKEY_DATAMODEL})
+		endif()
 	endif()
 endif()
 
diff --git a/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.cpp b/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.cpp
new file mode 100644
index 0000000..1bce2c3
--- /dev/null
+++ b/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.cpp
@@ -0,0 +1,227 @@
+/**
+ *  @file
+ *  @author     2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
+ *  @copyright  Simplified BSD
+ *
+ *  @cond
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the FreeBSD license as published by the FreeBSD
+ *  project.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  You should have received a copy of the FreeBSD license along with this
+ *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
+ *  @endcond
+ */
+
+#include "uscxml/Common.h"
+#include "uscxml/config.h"
+#include "SpiderMonkeyDataModel.h"
+
+#include "uscxml/Message.h"
+#include "uscxml/DOMUtils.h"
+#include <glog/logging.h>
+
+#ifdef BUILD_AS_PLUGINS
+#include <Pluma/Connector.hpp>
+#endif
+
+namespace uscxml {
+
+using namespace Arabica::XPath;
+using namespace Arabica::DOM;
+
+#ifdef BUILD_AS_PLUGINS
+PLUMA_CONNECTOR
+bool pluginConnect(pluma::Host& host) {
+	host.add( new SpiderMonkeyDataModelProvider() );
+	return true;
+}
+#endif
+
+static JSClass global_class = { "global",
+	JSCLASS_NEW_RESOLVE | JSCLASS_GLOBAL_FLAGS,
+	JS_PropertyStub,
+	JS_PropertyStub,
+	JS_PropertyStub,
+	JS_PropertyStub,
+	JS_EnumerateStub,
+	JS_ResolveStub,
+	JS_ConvertStub,
+	nullptr,
+	JSCLASS_NO_OPTIONAL_MEMBERS
+};
+
+	
+JSRuntime* SpiderMonkeyDataModel::_jsRuntime = NULL;
+	
+SpiderMonkeyDataModel::SpiderMonkeyDataModel() {
+	_jsCtx = NULL;
+}
+
+SpiderMonkeyDataModel::~SpiderMonkeyDataModel() {
+	if (_jsCtx)
+		JS_DestroyContext(_jsCtx);
+}
+	
+void SpiderMonkeyDataModel::reportError(JSContext *cx, const char *message, JSErrorReport *report) {
+#if 0
+ struct JSErrorReport {
+ const char      *filename;      /* source file name, URL, etc., or null */
+	uintN           lineno;         /* source line number */
+	const char      *linebuf;       /* offending source line without final \n */
+	const char      *tokenptr;      /* pointer to error token in linebuf */
+	const jschar    *uclinebuf;     /* unicode (original) line buffer */
+	const jschar    *uctokenptr;    /* unicode (original) token pointer */
+	uintN           flags;          /* error/warning, etc. */
+	uintN           errorNumber;    /* the error number, e.g. see js.msg */
+	const jschar    *ucmessage;     /* the (default) error message */
+	const jschar    **messageArgs;  /* arguments for the error message */
+};
+exceptionEvent.data.compound["stacktrace"] = Data(stackTrace, Data::VERBATIM);
+#endif
+	
+	Event exceptionEvent;
+	exceptionEvent.name = "error.execution";
+	exceptionEvent.eventType = Event::PLATFORM;
+
+	exceptionEvent.data.compound["cause"] = Data(message, Data::VERBATIM);;
+	exceptionEvent.data.compound["filename"] = Data(report->filename, Data::VERBATIM);
+	exceptionEvent.data.compound["sourceline"] = Data(report->linebuf, Data::VERBATIM);
+	exceptionEvent.data.compound["linenumber"] = Data(report->lineno, Data::INTERPRETED);
+
+	std::stringstream ssUnderline;
+	for (int i = 0; i < (report->tokenptr - report->linebuf); i++)
+		ssUnderline << " ";
+	ssUnderline << "^";
+
+	exceptionEvent.data.compound["sourcemark"] = Data(ssUnderline.str(), Data::VERBATIM);
+	throw exceptionEvent;
+}
+
+boost::shared_ptr<DataModelImpl> SpiderMonkeyDataModel::create(InterpreterImpl* interpreter) {
+	if (_jsRuntime == NULL) {
+    JSRuntime *rt = JS_NewRuntime(8L * 1024L * 1024L);
+    if (!rt) {
+			throw std::bad_alloc();
+		}
+	}
+	
+	boost::shared_ptr<SpiderMonkeyDataModel> dm = boost::shared_ptr<SpiderMonkeyDataModel>(new SpiderMonkeyDataModel());
+	dm->_interpreter = interpreter;
+	dm->_jsCtx = JS_NewContext(_jsRuntime, 8192);
+	if (!dm->_jsCtx) {
+		throw std::bad_alloc();
+	}
+	JS_SetOptions(dm->_jsCtx, JSOPTION_VAROBJFIX);
+	JS_SetErrorReporter(dm->_jsCtx, reportError);
+
+	dm->_global = JS_NewObject(dm->_jsCtx, &global_class, nullptr, nullptr);
+	if (!JS_InitStandardClasses(dm->_jsCtx, dm->_global)) {
+		throw std::bad_alloc();
+	}
+
+	return dm;
+}
+
+void SpiderMonkeyDataModel::pushContext() {
+}
+
+void SpiderMonkeyDataModel::popContext() {
+}
+
+void SpiderMonkeyDataModel::initialize() {
+}
+
+void SpiderMonkeyDataModel::setEvent(const Event& event) {
+}
+
+Data SpiderMonkeyDataModel::getStringAsData(const std::string& content) {
+	Data data;
+	return data;
+}
+
+
+bool SpiderMonkeyDataModel::validate(const std::string& location, const std::string& schema) {
+	return true;
+}
+
+bool SpiderMonkeyDataModel::isLocation(const std::string& expr) {
+	return true;
+}
+
+uint32_t SpiderMonkeyDataModel::getLength(const std::string& expr) {
+	return 0;
+}
+
+void SpiderMonkeyDataModel::setForeach(const std::string& item,
+                             const std::string& array,
+                             const std::string& index,
+                             uint32_t iteration) {
+}
+
+void SpiderMonkeyDataModel::eval(const Element<std::string>& scriptElem,
+																 const std::string& expr) {
+}
+
+bool SpiderMonkeyDataModel::isDeclared(const std::string& expr) {
+	return true;
+}
+
+bool SpiderMonkeyDataModel::evalAsBool(const std::string& expr) {
+	return evalAsBool(Arabica::DOM::Element<std::string>(), expr);
+}
+
+bool SpiderMonkeyDataModel::evalAsBool(const Arabica::DOM::Element<std::string>& node, const std::string& expr) {
+}
+
+std::string SpiderMonkeyDataModel::evalAsString(const std::string& expr) {
+	return "";
+}
+
+double SpiderMonkeyDataModel::evalAsNumber(const std::string& expr) {
+	return 0;
+}
+
+void SpiderMonkeyDataModel::assign(const Element<std::string>& assignElem,
+                         const Node<std::string>& node,
+                         const std::string& content) {
+}
+
+void SpiderMonkeyDataModel::assign(const std::string& location,
+                         const Data& data) {
+}
+
+void SpiderMonkeyDataModel::init(const Element<std::string>& dataElem,
+                       const Node<std::string>& doc,
+                       const std::string& content) {
+};
+
+void SpiderMonkeyDataModel::init(const std::string& location,
+                       const Data& data) {
+}
+
+std::string SpiderMonkeyDataModel::andExpressions(std::list<std::string> expressions) {
+	if (expressions.size() == 0)
+		return "";
+
+	if (expressions.size() == 1)
+		return *(expressions.begin());
+
+	std::ostringstream exprSS;
+	exprSS << "(";
+	std::string conjunction = "";
+	for (std::list<std::string>::const_iterator exprIter = expressions.begin();
+	        exprIter != expressions.end();
+	        exprIter++) {
+		exprSS << conjunction << "(" << *exprIter << ")";
+		conjunction = " && ";
+	}
+	exprSS << ")";
+	return exprSS.str();
+}
+
+}
\ No newline at end of file
diff --git a/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.h b/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.h
new file mode 100644
index 0000000..fbbdb69
--- /dev/null
+++ b/src/uscxml/plugins/datamodel/ecmascript/SpiderMonkey/SpiderMonkeyDataModel.h
@@ -0,0 +1,105 @@
+/**
+ *  @file
+ *  @author     2012-2014 Stefan Radomski (stefan.radomski@cs.tu-darmstadt.de)
+ *  @copyright  Simplified BSD
+ *
+ *  @cond
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the FreeBSD license as published by the FreeBSD
+ *  project.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *  You should have received a copy of the FreeBSD license along with this
+ *  program. If not, see <http://www.opensource.org/licenses/bsd-license>.
+ *  @endcond
+ */
+
+#ifndef SPIDERMONKEYDATAMODEL_H_88841EE2
+#define SPIDERMONKEYDATAMODEL_H_88841EE2
+
+#include "uscxml/Interpreter.h"
+#include <list>
+#include "jsapi.h"
+
+#ifdef BUILD_AS_PLUGINS
+#include "uscxml/plugins/Plugins.h"
+#endif
+
+namespace uscxml {
+class Event;
+class Data;
+}
+
+namespace uscxml {
+
+class SpiderMonkeyDataModel : public DataModelImpl {
+public:
+	SpiderMonkeyDataModel();
+	virtual ~SpiderMonkeyDataModel();
+	virtual boost::shared_ptr<DataModelImpl> create(InterpreterImpl* interpreter);
+
+	virtual std::list<std::string> getNames() {
+		std::list<std::string> names;
+		names.push_back("ecmascript");
+		return names;
+	}
+
+	virtual void initialize();
+	virtual void setEvent(const Event& event);
+
+	virtual bool validate(const std::string& location, const std::string& schema);
+	virtual bool isLocation(const std::string& expr);
+
+	virtual uint32_t getLength(const std::string& expr);
+	virtual void setForeach(const std::string& item,
+	                        const std::string& array,
+	                        const std::string& index,
+	                        uint32_t iteration);
+	virtual void pushContext();
+	virtual void popContext();
+
+	virtual void eval(const Arabica::DOM::Element<std::string>& scriptElem,
+	                  const std::string& expr);
+	virtual void assign(const Arabica::DOM::Element<std::string>& assignElem,
+	                    const Arabica::DOM::Node<std::string>& node,
+	                    const std::string& content);
+	virtual void assign(const std::string& location,
+	                    const Data& data);
+
+	virtual void init(const Arabica::DOM::Element<std::string>& dataElem,
+	                  const Arabica::DOM::Node<std::string>& node,
+	                  const std::string& content);
+	virtual void init(const std::string& location,
+	                  const Data& data);
+
+	virtual std::string andExpressions(std::list<std::string>);
+
+	virtual Data getStringAsData(const std::string& content);
+
+	virtual bool isDeclared(const std::string& expr);
+
+	virtual std::string evalAsString(const std::string& expr);
+	virtual bool evalAsBool(const Arabica::DOM::Element<std::string>& node, const std::string& expr);
+	virtual bool evalAsBool(const std::string& expr);
+	virtual double evalAsNumber(const std::string& expr);
+
+	static void reportError(JSContext *cx, const char *message, JSErrorReport *report);
+
+protected:
+
+	JSObject* _global;
+	
+	JSContext* _jsCtx;
+	static JSRuntime* _jsRuntime;
+};
+
+#ifdef BUILD_AS_PLUGINS
+PLUMA_INHERIT_PROVIDER(SpiderMonkeyDataModel, DataModelImpl);
+#endif
+
+}
+
+#endif /* end of include guard: SPIDERMONKEYDATAMODEL_H_88841EE2 */
diff --git a/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.cpp b/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.cpp
index 7db9e66..fc18e18 100644
--- a/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.cpp
+++ b/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.cpp
@@ -27,7 +27,7 @@
 #include <Pluma/Connector.hpp>
 #endif
 
-#define ISSUE_REQUEST(name) {\
+#define ISSUE_REQUEST(name, block) {\
 	Arabica::DOM::Document<std::string> name##XML = name.toXML(true);\
 	name##XML.getDocumentElement().setPrefix("mmi");\
 	std::stringstream name##XMLSS;\
@@ -36,7 +36,7 @@
 	std::cout << "SEND: " << name##XMLSS.str() << std::endl; \
 	name##URL.setOutContent(name##XMLSS.str());\
 	name##URL.addOutHeader("Content-type", "application/xml");\
-	name##URL.download(false);\
+	name##URL.download(block);\
 }
 
 namespace uscxml {
@@ -72,7 +72,7 @@ bool VoiceXMLInvoker::httpRecvRequest(const HTTPServer::Request& request) {
 	}
 	
 	const Arabica::DOM::Node<std::string>& node = request.data.at("content").node;
-	std::cout << "RCVD: " << node << std::endl;
+//	std::cout << "RCVD: " << node << std::endl;
 
 	switch(MMIEvent::getType(node)) {
 		case MMIEvent::NEWCONTEXTRESPONSE: {
@@ -95,7 +95,7 @@ bool VoiceXMLInvoker::httpRecvRequest(const HTTPServer::Request& request) {
 					std::stringstream contentSS;
 					startReq.contentDOM = _invokeReq.dom;
 				}
-				ISSUE_REQUEST(startReq);
+				ISSUE_REQUEST(startReq, false);
 
 			} else {
 				// already got a context!
@@ -113,20 +113,26 @@ bool VoiceXMLInvoker::httpRecvRequest(const HTTPServer::Request& request) {
 			_compState = MMI_IDLE;
 			break;
 		}
-	
-		case MMIEvent::EXTENSIONNOTIFICATION: {
-			ExtensionNotification resp = ExtensionNotification::fromXML(node);
-			Event ev;
-			ev.name = "mmi.extensionnotification";
-			if (resp.dataDOM) {
-				ev.dom = resp.dataDOM;
-			} else if(resp.data.size() > 0) {
-				ev.data = Data::fromJSON(resp.data); // try to parse as JSON
-				if (ev.data.empty()) {
-					ev.content = resp.data;
+
+		case MMIEvent::STATUSRESPONSE: {
+			StatusResponse resp = StatusResponse::fromXML(node);
+			switch (resp.status) {
+				case StatusResponse::DEAD:
+					_compState = MMI_DEAD;
+				case StatusResponse::FAILURE: {
+					Event ev = resp;
+					returnEvent(ev);
+					break;
 				}
+				default:
+					break;
 			}
-			returnEvent(ev);
+			break;
+		}
+
+		case MMIEvent::EXTENSIONNOTIFICATION: {
+			Event resp = ExtensionNotification::fromXML(node);
+			returnEvent(resp);
 		}
 			
 		default:
@@ -169,7 +175,7 @@ void VoiceXMLInvoker::invoke(const InvokeRequest& req) {
 	newCtxReq.source = _url;
 	newCtxReq.target = _target;
 	newCtxReq.requestId = uscxml::UUID::getUUID();
-	ISSUE_REQUEST(newCtxReq);
+	ISSUE_REQUEST(newCtxReq, false);
 
 	_isRunning = true;
 	_thread = new tthread::thread(VoiceXMLInvoker::run, this);
@@ -182,11 +188,12 @@ void VoiceXMLInvoker::uninvoke() {
 	clrCtxReq.source = _url;
 	clrCtxReq.target = _target;
 	clrCtxReq.requestId = uscxml::UUID::getUUID();
-	ISSUE_REQUEST(clrCtxReq);
+	ISSUE_REQUEST(clrCtxReq, false);
 
 	if (_isRunning)
 		_isRunning = false;
 	
+	// unblock queue
 	SendRequest req;
 	_workQueue.push(req);
 	
@@ -222,8 +229,12 @@ void VoiceXMLInvoker::process(SendRequest& req) {
 		return;
 	}
 	
+	if (_compState != MMI_RUNNING)
+		// remote component is not running
+		return;
+	
 	// dispatch over send request
-
+	// Is there something special to do here?
 	
 	// if we did nothing else, send as ExtensionNotification
 	ExtensionNotification extNotif;
@@ -251,8 +262,7 @@ void VoiceXMLInvoker::process(SendRequest& req) {
 		extNotif.data = Data::toJSON(req.data);
 	}
 	
-	ISSUE_REQUEST(extNotif);
-
+	ISSUE_REQUEST(extNotif, false);
 }
 	
 }
\ No newline at end of file
diff --git a/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.h b/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.h
index 6f2a248..4ad5023 100644
--- a/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.h
+++ b/src/uscxml/plugins/invoker/vxml/VoiceXMLInvoker.h
@@ -37,7 +37,8 @@ public:
 	enum ComponentState {
 		MMI_IDLE,
 		MMI_PAUSED,
-		MMI_RUNNING
+		MMI_RUNNING,
+		MMI_DEAD
 	};
 	
 	VoiceXMLInvoker();
diff --git a/src/uscxml/plugins/invoker/xhtml/XHTMLInvoker.cpp b/src/uscxml/plugins/invoker/xhtml/XHTMLInvoker.cpp
index 285db72..eb82edb 100644
--- a/src/uscxml/plugins/invoker/xhtml/XHTMLInvoker.cpp
+++ b/src/uscxml/plugins/invoker/xhtml/XHTMLInvoker.cpp
@@ -88,7 +88,17 @@ bool XHTMLInvoker::httpRecvRequest(const HTTPServer::Request& req) {
 				ev.name = req.data.at("type").atom;
 			}
 			ev.origin = _invokeId;
-			ev.initContent(req.data.at("content").atom);
+			
+			// initialize data
+			ev.data = Data::fromJSON(req.data.at("content").atom);
+			if (ev.data.empty()) {
+				if (req.dom) {
+					ev.dom = req.dom;
+				} else {
+					ev.content = req.content;
+				}
+			}
+			
 			ev.data.compound["Connection"] = req.data;
 			// content is already on ev.raw
 			ev.data.compound["Connection"].compound.erase("content");
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index b879401..718409f 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -152,12 +152,12 @@ target_link_libraries(test-sockets uscxml)
 set_target_properties(test-sockets PROPERTIES FOLDER "Tests")
 
 
-# if (NOT WIN32)
-# 	add_executable(test-mmi src/test-mmi.cpp)
-# 	target_link_libraries(test-mmi uscxml)
-# 	add_test(test-url ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test-mmi)
-# 	set_target_properties(test-mmi PROPERTIES FOLDER "Tests")
-# endif()
+if (NOT WIN32)
+	add_executable(test-mmi src/test-mmi.cpp)
+	target_link_libraries(test-mmi uscxml)
+	add_test(test-mmi ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/test-mmi)
+	set_target_properties(test-mmi PROPERTIES FOLDER "Tests")
+endif()
 
 # add_executable(test-curl-multi-api src/test-curl-multi-api.cpp)
 # target_link_libraries(test-curl-multi-api uscxml)
diff --git a/test/src/test-arabica-namespaces.cpp b/test/src/test-arabica-namespaces.cpp
index bc3e62f..32feacd 100644
--- a/test/src/test-arabica-namespaces.cpp
+++ b/test/src/test-arabica-namespaces.cpp
@@ -95,8 +95,8 @@ static void validateRootFoo(std::pair<Document<std::string>, NameSpaceInfo>& par
 	Node<std::string> root = document.getDocumentElement();
 	_xpath.setNamespaceContext(*nsInfo.getNSContext());
 
-	assert(TAGNAME(root) == nsInfo.xmlNSPrefix + "root");
-	assert(LOCALNAME(root) == "root");
+	assert(TAGNAME_CAST(root) == nsInfo.xmlNSPrefix + "root");
+	assert(LOCALNAME_CAST(root) == "root");
 	NodeSet<std::string> foosFiltered = InterpreterImpl::filterChildElements(nsInfo.xmlNSPrefix + "foo", root);
 	assert(foosFiltered.size() == 3);
 	NodeSet<std::string> foosXPath = _xpath.evaluate("//" + nsInfo.xpathPrefix + "foo", root).asNodeSet();
@@ -104,8 +104,8 @@ static void validateRootFoo(std::pair<Document<std::string>, NameSpaceInfo>& par
 
 	for (int i = 0; i < 3; i++) {
 		assert(foosFiltered[i] == foosXPath[i]);
-		assert(TAGNAME(foosFiltered[i]) == nsInfo.xmlNSPrefix + "foo");
-		assert(LOCALNAME(foosFiltered[i]) == "foo");
+		assert(TAGNAME_CAST(foosFiltered[i]) == nsInfo.xmlNSPrefix + "foo");
+		assert(LOCALNAME_CAST(foosFiltered[i]) == "foo");
 	}
 
 }
@@ -126,8 +126,8 @@ static void validateRootFooBar(std::pair<Document<std::string>, NameSpaceInfo>&
 
 	for (int i = 0; i < 3; i++) {
 		assert(barsFiltered[i] == barsXPath[i]);
-		assert(TAGNAME(barsFiltered[i]) == nsInfo.xmlNSPrefix + "bar");
-		assert(LOCALNAME(barsFiltered[i]) == "bar");
+		assert(TAGNAME_CAST(barsFiltered[i]) == nsInfo.xmlNSPrefix + "bar");
+		assert(LOCALNAME_CAST(barsFiltered[i]) == "bar");
 	}
 
 }
@@ -141,8 +141,8 @@ static void validateRootFooBarBaz(std::pair<Document<std::string>, NameSpaceInfo
 	Node<std::string> root = document.getDocumentElement();
 	_xpath.setNamespaceContext(*nsInfo.getNSContext());
 
-	assert(TAGNAME(root) == nsInfo.xmlNSPrefix + "root");
-	assert(LOCALNAME(root) == "root");
+	assert(TAGNAME_CAST(root) == nsInfo.xmlNSPrefix + "root");
+	assert(LOCALNAME_CAST(root) == "root");
 
 	NodeSet<std::string> bazsFiltered = InterpreterImpl::filterChildElements(nsInfo.xmlNSPrefix + "baz", root);
 	assert(bazsFiltered.size() == 3);
@@ -151,8 +151,8 @@ static void validateRootFooBarBaz(std::pair<Document<std::string>, NameSpaceInfo
 
 	for (int i = 0; i < 3; i++) {
 		assert(bazsFiltered[i] == bazsXPath[i]);
-		assert(TAGNAME(bazsFiltered[i]) == nsInfo.xmlNSPrefix + "baz");
-		assert(LOCALNAME(bazsFiltered[i]) == "baz");
+		assert(TAGNAME_CAST(bazsFiltered[i]) == nsInfo.xmlNSPrefix + "baz");
+		assert(LOCALNAME_CAST(bazsFiltered[i]) == "baz");
 	}
 
 }
diff --git a/test/src/test-mmi.cpp b/test/src/test-mmi.cpp
index 0b9f5f9..eeb71ee 100644
--- a/test/src/test-mmi.cpp
+++ b/test/src/test-mmi.cpp
@@ -1,7 +1,7 @@
 #include <iostream>
 #include <string>
 
-#include "uscxml/plugins/ioprocessor/modality/MMIMessages.h"
+#include "uscxml/messages/MMIMessages.h"
 
 #include <SAX/helpers/InputSourceResolver.hpp>
 #include <DOM/SAX2DOM/SAX2DOM.hpp>
@@ -30,19 +30,30 @@ int main(int argc, char** argv) {
 		// --- NewContextRequest
 		std::stringstream ss;
 		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\"><mmi:NewContextRequest mmi:Source=\"someURI\" mmi:Target=\"someOtherURI\" mmi:RequestID=\"request-1\"></mmi:NewContextRequest></mmi:mmi>";
+		
 		NewContextRequest msg = NewContextRequest::fromXML(xmlToDoc(ss.str()));
 		assert(boost::iequals(msg.tagName, "NewContextRequest"));
 		assert(boost::iequals(msg.source, "someURI"));
 		assert(boost::iequals(msg.target, "someOtherURI"));
 		assert(boost::iequals(msg.requestId, "request-1"));
 		assert(boost::iequals(msg.data, ""));
-
+		
 		NewContextRequest msg2 = NewContextRequest::fromXML(msg.toXML());
 		assert(boost::iequals(msg2.tagName, "NewContextRequest"));
 		assert(boost::iequals(msg2.source, "someURI"));
 		assert(boost::iequals(msg2.target, "someOtherURI"));
 		assert(boost::iequals(msg2.requestId, "request-1"));
 		assert(boost::iequals(msg2.data, ""));
+
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+		
+		Event ev = msg;
+		assert(ev.name == "mmi.request.newcontext");
+		assert(ev.origin == msg.source);
 	}
 
 	{
@@ -69,10 +80,20 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "URI-1"));
 		assert(boost::iequals(msg2.data, ""));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.newcontext");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
-		// --- PrepareRequest
+		// --- PrepareRequest ContentURL
 		std::stringstream ss;
 		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\"> <mmi:PrepareRequest mmi:Source=\"someURI\" mmi:Target=\"someOtherURI\"  mmi:Context=\"URI-1\" mmi:RequestID=\"request-1\"> <mmi:ContentURL mmi:href=\"someContentURI\" mmi:max-age=\"\" mmi:fetchtimeout=\"1s\"/> </mmi:PrepareRequest></mmi:mmi>";
 		PrepareRequest msg = PrepareRequest::fromXML(xmlToDoc(ss.str()));
@@ -99,10 +120,20 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.contentURL.maxAge, ""));
 		assert(boost::iequals(msg2.contentURL.fetchTimeout, "1s"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.prepare");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
-		// --- PrepareRequest
+		// --- PrepareRequest Content
 		std::stringstream ss;
 		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\" xmlns:vxml=\"http://www.w3.org/2001/vxml\"> <mmi:PrepareRequest mmi:Source=\"someURI\" mmi:Target=\"someOtherURI\"  mmi:Context=\"URI-1\" mmi:RequestID=\"request-1\" > <mmi:content> <vxml:vxml version=\"2.0\"> <vxml:form> <vxml:block>Hello World!</vxml:block> </vxml:form> </vxml:vxml> </mmi:content> </mmi:PrepareRequest></mmi:mmi>";
 		PrepareRequest msg = PrepareRequest::fromXML(xmlToDoc(ss.str()));
@@ -111,8 +142,8 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg.target, "someOtherURI"));
 		assert(boost::iequals(msg.requestId, "request-1"));
 		assert(boost::iequals(msg.context, "URI-1"));
-		assert(msg.content.size() > 0);
-
+		assert(msg.contentDOM);
+		
 		PrepareRequest msg2 = PrepareRequest::fromXML(msg.toXML());
 		assert(boost::iequals(msg2.tagName, "PrepareRequest"));
 		assert(boost::iequals(msg2.source, "someURI"));
@@ -121,6 +152,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "URI-1"));
 		assert(msg2.content.size() > 0);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.prepare");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -143,6 +184,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.prepare");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -167,6 +218,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.statusInfo, " NotAuthorized "));
 		assert(msg2.status == StatusResponse::FAILURE);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.prepare");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -187,9 +248,52 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.requestId, "request-1"));
 		assert(boost::iequals(msg2.context, "URI-1"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.start");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
+		// --- StartRequest
+		std::stringstream ss;
+		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\"> <mmi:StartRequest mmi:Source=\"someURI\" mmi:Target=\"someOtherURI\" mmi:Context=\"URI-1\" mmi:RequestID=\"request-1\"> <mmi:ContentURL mmi:href=\"someContentURI\" mmi:max-age=\"\" mmi:fetchtimeout=\"1s\"/> <mmi:Data> { \"foo\": 12 } </mmi:Data> </mmi:StartRequest></mmi:mmi>";
+		StartRequest msg = StartRequest::fromXML(xmlToDoc(ss.str()));
+		assert(boost::iequals(msg.tagName, "StartRequest"));
+		assert(boost::iequals(msg.source, "someURI"));
+		assert(boost::iequals(msg.target, "someOtherURI"));
+		assert(boost::iequals(msg.requestId, "request-1"));
+		assert(boost::iequals(msg.context, "URI-1"));
+		
+		StartRequest msg2 = StartRequest::fromXML(msg.toXML());
+		assert(boost::iequals(msg2.tagName, "StartRequest"));
+		assert(boost::iequals(msg2.source, "someURI"));
+		assert(boost::iequals(msg2.target, "someOtherURI"));
+		assert(boost::iequals(msg2.requestId, "request-1"));
+		assert(boost::iequals(msg2.context, "URI-1"));
+		
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+		
+		Event ev = msg;
+		assert(ev.name == "mmi.request.start");
+		assert(ev.data.compound["foo"] == 12);
+		assert(ev.origin == msg.source);
+		
+	}
+
+	
+	
+	{
 		// --- StartResponse
 		std::stringstream ss;
 		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\"> <mmi:StartResponse mmi:Source=\"someURI\" mmi:Target=\"someOtherURI\" mmi:Context=\"someURI\" mmi:RequestID=\"request-1\"  mmi:Status=\"failure\"> <mmi:statusInfo> NotAuthorized </mmi:statusInfo> </mmi:StartResponse></mmi:mmi>";
@@ -211,6 +315,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.statusInfo, " NotAuthorized "));
 		assert(msg2.status == StatusResponse::FAILURE);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.start");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -235,6 +349,16 @@ int main(int argc, char** argv) {
 		assert(msg2.data.size() > 0);
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.notification.done");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -259,6 +383,16 @@ int main(int argc, char** argv) {
 		assert(msg2.data.size() > 0);
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.notification.done");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -279,6 +413,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.requestId, "request-1"));
 		assert(boost::iequals(msg2.context, "someURI"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.cancel");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -301,6 +445,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.cancel");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -321,6 +475,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.requestId, "request-1"));
 		assert(boost::iequals(msg2.context, "someURI"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.pause");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -343,6 +507,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.pause");
+		assert(ev.origin == msg.source);
+		
 	}
 
 	{
@@ -363,6 +537,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.requestId, "request-1"));
 		assert(boost::iequals(msg2.context, "someURI"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.resume");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -385,6 +569,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.resume");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -407,6 +601,49 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(boost::iequals(msg2.name, "appEvent"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "appEvent");
+		assert(ev.origin == msg.source);
+
+	}
+
+	{
+		// --- ExtensionNotification
+		std::stringstream ss;
+		ss << "<mmi:mmi xmlns:mmi=\"http://www.w3.org/2008/04/mmi-arch\" version=\"1.0\"> <mmi:ExtensionNotification mmi:Name=\"appEvent\" mmi:Source=\"someURI\"  mmi:Target=\"someOtherURI\" mmi:Context=\"someURI\" mmi:RequestID=\"request-1\"> <mmi:Data> { \"foo\": 12 } </mmi:Data> </mmi:ExtensionNotification></mmi:mmi>";
+		ExtensionNotification msg = ExtensionNotification::fromXML(xmlToDoc(ss.str()));
+		assert(boost::iequals(msg.tagName, "ExtensionNotification"));
+		assert(boost::iequals(msg.source, "someURI"));
+		assert(boost::iequals(msg.target, "someOtherURI"));
+		assert(boost::iequals(msg.requestId, "request-1"));
+		assert(boost::iequals(msg.context, "someURI"));
+		assert(boost::iequals(msg.name, "appEvent"));
+		
+		ExtensionNotification msg2 = ExtensionNotification::fromXML(msg.toXML());
+		assert(boost::iequals(msg2.tagName, "ExtensionNotification"));
+		assert(boost::iequals(msg2.source, "someURI"));
+		assert(boost::iequals(msg2.target, "someOtherURI"));
+		assert(boost::iequals(msg2.requestId, "request-1"));
+		assert(boost::iequals(msg2.context, "someURI"));
+		assert(boost::iequals(msg2.name, "appEvent"));
+		
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+		
+		Event ev = msg;
+		assert(ev.name == "appEvent");
+		assert(ev.data.compound["foo"] == 12);
+		assert(ev.origin == msg.source);
+		
 	}
 
 	{
@@ -427,6 +664,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.requestId, "request-2"));
 		assert(boost::iequals(msg2.context, "someURI"));
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.clearcontext");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -449,6 +696,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "someURI"));
 		assert(msg2.status == StatusResponse::SUCCESS);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.clearcontext");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -471,6 +728,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "aToken"));
 		assert(msg2.automaticUpdate);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.request.status");
+		assert(ev.origin == msg.source);
+
 	}
 
 	{
@@ -493,6 +760,16 @@ int main(int argc, char** argv) {
 		assert(boost::iequals(msg2.context, "aToken"));
 		assert(msg2.status == StatusResponse::ALIVE);
 
+		std::stringstream xml1SS;
+		std::stringstream xml2SS;
+		xml1SS << msg.toXML();
+		xml2SS << msg2.toXML();
+		assert(xml1SS.str() == xml2SS.str());
+
+		Event ev = msg;
+		assert(ev.name == "mmi.response.status");
+		assert(ev.origin == msg.source);
+
 	}
 
 }
\ No newline at end of file
diff --git a/test/src/test-vxml-mmi-http.cpp b/test/src/test-vxml-mmi-http.cpp
index 0e4f5a9..2b2cd25 100644
--- a/test/src/test-vxml-mmi-http.cpp
+++ b/test/src/test-vxml-mmi-http.cpp
@@ -22,7 +22,7 @@
 #include "XGetopt.h"
 #endif
 
-#define ISSUE_REQUEST(name) {\
+#define ISSUE_REQUEST(name, block) {\
 	Arabica::DOM::Document<std::string> name##XML = name.toXML(true);\
 	name##XML.getDocumentElement().setPrefix("mmi");\
 	std::stringstream name##XMLSS;\
@@ -31,7 +31,8 @@
 	std::cout << "SEND:" << std::endl << name##XMLSS.str() << std::flush;\
 	name##URL.setOutContent(name##XMLSS.str());\
 	name##URL.addOutHeader("Content-type", "application/xml");\
-	name##URL.download(false);\
+	name##URL.download(block);\
+	std::cout << "OK" << std::endl << std::flush;\
 }
 
 using namespace uscxml;
@@ -144,9 +145,10 @@ int main(int argc, char** argv) {
 		newCtxReq.source = source;
 		newCtxReq.target = target;
 		newCtxReq.requestId = uscxml::UUID::getUUID();
-			
+
 		Requests[newCtxReq.requestId] = &newCtxReq;
-		ISSUE_REQUEST(newCtxReq);
+		
+		ISSUE_REQUEST(newCtxReq, false);
 
 		while(Replies.find(newCtxReq.requestId) == Replies.end())
 			Cond.wait(Mutex);
@@ -160,7 +162,7 @@ int main(int argc, char** argv) {
 		//"https://raw.githubusercontent.com/Roland-Taizun-Azhar/TaskAssistance-Project/master/WebContent/hello.vxml";
 		
 		Requests[startReq.requestId] = &startReq;
-		ISSUE_REQUEST(startReq);
+		ISSUE_REQUEST(startReq, false);
 
 		while(Replies.find(startReq.requestId) == Replies.end())
 			Cond.wait(Mutex);
diff --git a/test/uscxml/test-jvoicexml.scxml b/test/uscxml/test-jvoicexml.scxml
index ca423ad..2e60cf3 100644
--- a/test/uscxml/test-jvoicexml.scxml
+++ b/test/uscxml/test-jvoicexml.scxml
@@ -1,54 +1,116 @@
-<scxml xmlns="http://www.w3.org/2005/07/scxml" 
-	     xmlns:vxml="http://www.w3.org/2001/vxml" 
-	     datamodel="ecmascript">
-	<script src="http://uscxml.tk.informatik.tu-darmstadt.de/scripts/dump.js" />
+<?xml version="1.0"?>
+<scxml xmlns="http://www.w3.org/2005/07/scxml" xmlns:vxml="http://www.w3.org/2001/vxml" datamodel="ecmascript">
+	<!-- get dump() function into datamodel -->
+	<script src="http://uscxml.tk.informatik.tu-darmstadt.de/scripts/dump.js"/>
+	<script>
+		vxmlTargetURL = "http://localhost:9090/mmi";
+	</script>
 	
-	<state id="start">
-		<invoke type="heartbeat">
-			<param name="interval" expr="'5s'" />
-		</invoke>
-
-		<state id="vxmlHello">
-			<invoke src="https://raw.githubusercontent.com/Roland-Taizun-Azhar/TaskAssistance-Project/master/WebContent/hello.vxml" type="vxml" id="vxml">
-				<param name="target" expr="'http://localhost:9090/mmi'" />
-			</invoke>
-			<!--invoke type="vxml" id="vxml">
-				<param name="target" expr="'http://localhost:9090/mmi'" />
+	<state id="prompts">
+		<transition event="error" target="done">
+			<log expr="'An error occured:' + _event" />
+		</transition>
+		
+		<state id="vxmlPrompt1">
+			<!-- Test that rendering a prompt sends start and done events -->
+			<invoke type="vxml" id="vxml">
+				<param name="target" expr="vxmlTargetURL"/>
+				<content>
+					<vxml:prompt>Testing start and done events</vxml:prompt>
+				</content>
 				<finalize>
 					<script>dump(_event);</script>
 				</finalize>
-				
+			</invoke>
+			
+			<state id="waitForPrompt1Start">
+				<transition event="vxml.output.start" target="waitForPrompt1Done"/>
+			</state>
+			<state id="waitForPrompt1Done">
+				<transition event="vxml.output.done" target="vxmlPrompt2"/>
+			</state>
+		</state>
+		
+		
+		<state id="vxmlPrompt2">
+			<!-- Test prompts in form with goto -->
+			<invoke type="vxml" id="vxml">
+				<param name="target" expr="vxmlTargetURL"/>
 				<content>
-					<vxml:vxml version="2.1" xml:lang="en" 
-						xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-						xsi:schematicLocation="http://www.w3.org/2001/vxml http://www.w3.org/TR/voicexml20/vxml.xsd">
+					<vxml:vxml version="2.1">
 						<vxml:form id="say_hello">
 							<vxml:block>
-								Hello World!
-								<vxml:goto next="#say_goodbye" />
+								Testing prompts in form
+								<vxml:goto next="#say_goodbye"/>
 							</vxml:block>
 						</vxml:form>
 						<vxml:form id="say_goodbye">
 							<vxml:block>
-								<vxml:prompt>Goodbye!</vxml:prompt>
+								<vxml:prompt>with goto</vxml:prompt>
 							</vxml:block>
 						</vxml:form>
 					</vxml:vxml>
 				</content>
-			</invoke-->
+				<finalize>
+					<script>dump(_event);</script>
+				</finalize>
+			</invoke>
 			
-			<!-- <transition event="heartbeat" target="idle" /> -->
+			<state id="waitForPrompt2HelloStart">
+				<transition event="vxml.output.start" target="waitForPrompt2HelloDone"/>
+			</state>
+			<state id="waitForPrompt2HelloDone">
+				<transition event="vxml.output.done" target="waitForPrompt2ByeStart"/>
+			</state>
+			<state id="waitForPrompt2ByeStart">
+				<transition event="vxml.output.start" target="waitForPrompt2ByeDone"/>
+			</state>
+			<state id="waitForPrompt2ByeDone">
+				<transition event="vxml.output.done" target="waitForPrompt2HelloDone"/>
+			</state>
 		</state>
+	</state>
+	
+	
+	
+	<state id="forms">
+		<transition event="error" target="done">
+			<log expr="'An error occured:' + _event" />
+		</transition>
+
+		<invoke type="vxml" id="vxml">
+			<param name="target" expr="vxmlTargetURL"/>
+			<content>
+				<vxml:vxml version="2.1">
+					<vxml:form id="launch_missiles">
+						<vxml:field name="user_id" type="digits">
+							<vxml:prompt>What is your username</vxml:prompt>
+						</vxml:field>
+						<vxml:field name="password">
+							<vxml:prompt>What is the code word?</vxml:prompt>
+							<vxml:grammar version="1.0" root="root">
+								<vxml:rule id="root" scope="public">rutabaga</vxml:rule>
+							</vxml:grammar>
+							<vxml:help>It is the name of an obscure vegetable.</vxml:help>
+							<vxml:catch event="nomatch noinput" count="3">
+								<vxml:prompt>Security violation!</vxml:prompt>
+							</vxml:catch>
+						</vxml:field>
+					</vxml:form>
+				</vxml:vxml>
+			</content>
+			<finalize>
+				<script>dump(_event);</script>
+			</finalize>
+		</invoke>
 		
-		<state id="idle">
-			<onentry>
-				<log expr="'Idling!'" />
-			</onentry>
-			
-			<transition event="heartbeat" target="vxmlHello">
-				<log expr="'Foo!'" />
+		<state id="waitForMissileEvents">
+			<transition event="vxml.input.field.user_id" target="done">
+				<log expr="'Welcome ' + _event.data.value + ' please provide credentials!'" />
 			</transition>
+			<transition event="vxml.input.field.password" />
 		</state>
-		
 	</state>
-</scxml>
\ No newline at end of file
+	
+	<final id="done" />
+</scxml>