diff --git a/ohos_nweb/src/capi/arkweb_model.h b/ohos_nweb/src/capi/arkweb_model.h
index d3f5c3f52ae43544c658b982851e6e9932684621..b4d85516124ad76eb14a01e61a7163f543c4fd46 100644
--- a/ohos_nweb/src/capi/arkweb_model.h
+++ b/ohos_nweb/src/capi/arkweb_model.h
@@ -48,6 +48,22 @@ struct ArkWeb_WebMessage {
   size_t dataLength;
 };
 
+/**
+ * @brief Defines the ArkWeb_WebMessage.
+ *
+ * @since 14
+ */
+struct ArkWeb_JavaScriptValue {
+  /** The data type carried in the ArkWeb_WebMessage. */
+  ArkWeb_JavaScriptValueType type;
+
+  /** The data in ArkWeb_WebMessage. */
+  void* data;
+
+  /** The data length. */
+  size_t dataLength;
+};
+
 void OH_ArkWeb_RunJavaScript(const char* webTag,
                              const ArkWeb_JavaScriptObject* javascriptObject);
 void OH_ArkWeb_RegisterJavaScriptProxy(const char* webTag,
@@ -66,28 +82,28 @@ void OH_ArkWeb_OnPageEnd(const char* webTag,
 void OH_ArkWeb_OnDestroy(const char* webTag,
                          ArkWeb_OnComponentCallback callback,
                          void* userData);
-void OH_ArkWeb_RegisterAsyncJavaScriptProxy(const char* webTag,
-                                       const ArkWeb_ProxyObject* proxyObject);
+void OH_ArkWeb_RegisterAsyncJavaScriptProxy(
+    const char* webTag,
+    const ArkWeb_ProxyObject* proxyObject);
 void RegisterJavaScriptProxy(const char* webTag,
                              const ArkWeb_ProxyObject* proxyObject,
                              bool isAsync,
                              const char* permission);
-void OH_ArkWeb_RegisterJavaScriptProxyEx(const char* webTag,
-                                         const ArkWeb_ProxyObject* proxyObject,
-                                         const char* permission);
 ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(const char* webTag,
                                                           size_t* size);
 void OH_ArkWeb_DestroyWebMessagePorts(ArkWeb_WebMessagePortPtr** ports,
                                       size_t size);
-ArkWeb_ErrorCode OH_ArkWeb_PostWebMessage(const char* webTag,
-                              const char* name,
-                              ArkWeb_WebMessagePortPtr* webMessagePorts,
-                              size_t size,
-                              const char* url);
-
-ArkWeb_ErrorCode OH_WebMessage_PostMessage(const ArkWeb_WebMessagePortPtr webMessagePort,
-                               const char* webTag,
-                               const ArkWeb_WebMessagePtr message);
+ArkWeb_ErrorCode OH_ArkWeb_PostWebMessage(
+    const char* webTag,
+    const char* name,
+    ArkWeb_WebMessagePortPtr* webMessagePorts,
+    size_t size,
+    const char* url);
+
+ArkWeb_ErrorCode OH_WebMessage_PostMessage(
+    const ArkWeb_WebMessagePortPtr webMessagePort,
+    const char* webTag,
+    const ArkWeb_WebMessagePtr message);
 void OH_WebMessage_Close(const ArkWeb_WebMessagePortPtr webMessagePort,
                          const char* webTag);
 void OH_WebMessage_SetMessageEventHandler(
@@ -123,6 +139,25 @@ void OH_CookieManager_ClearAllCookiesSync(bool incognito);
 
 void OH_CookieManager_ClearSessionCookiesSync();
 
+void OH_ArkWeb_RegisterJavaScriptProxyEx(
+    const char* webTag,
+    const ArkWeb_ProxyObjectWithResult* proxyObject,
+    const char* permission);
+
+void OH_ArkWeb_RegisterAsyncJavaScriptProxyEx(
+    const char* webTag,
+    const ArkWeb_ProxyObject* proxyObject,
+    const char* permission);
+
+void RegisterJavaScriptProxyEx(const char* webTag,
+                               const ArkWeb_ProxyObjectWithResult* proxyObject,
+                               bool isAsync,
+                               const char* permission);
+
+ArkWeb_JavaScriptValuePtr OH_JavaScript_CreateJavaScriptValue(
+    ArkWeb_JavaScriptValueType type,
+    void* data,
+    size_t dataLength);
 #ifdef __cplusplus
 }
 #endif
diff --git a/ohos_nweb/src/capi/arkweb_type.h b/ohos_nweb/src/capi/arkweb_type.h
index d7a7dfb5afd943cb9b26615b5607fb234befef69..2a7b08073a5b5b0646fe1868b74c7bde56c137b6 100644
--- a/ohos_nweb/src/capi/arkweb_type.h
+++ b/ohos_nweb/src/capi/arkweb_type.h
@@ -68,6 +68,20 @@ typedef enum ArkWeb_WebMessageType {
     ARKWEB_BUFFER
 } ArkWeb_WebMessageType;
 
+/**
+ * @brief Defines the data type carried in a ArkWeb_JavaScriptValue.
+ *
+ * @since 14
+ */
+typedef enum ArkWeb_JavaScriptValueType {
+    /** Represent error data */
+    ARKWEB_JAVASCRIPT_NONE = 0,
+    /** The data carried in the ArkWeb_JavaScriptValue is string. */
+    ARKWEB_JAVASCRIPT_STRING,
+    /** The data carried in the ArkWeb_JavaScriptValue is bool. */
+    ARKWEB_JAVASCRIPT_BOOL
+} ArkWeb_JavaScriptValueType;
+
 /**
  * @brief Defines the ArkWeb_WebMessage.
  *
@@ -75,6 +89,13 @@ typedef enum ArkWeb_WebMessageType {
  */
 typedef struct ArkWeb_WebMessage* ArkWeb_WebMessagePtr;
 
+/**
+ * @brief Defines the ArkWeb_JavaScriptValuePtr.
+ *
+ * @since 14
+ */
+typedef struct ArkWeb_JavaScriptValue* ArkWeb_JavaScriptValuePtr;
+
 /**
  * @brief Defines the javascript callback of the native ArkWeb.
  *
@@ -91,6 +112,19 @@ typedef void (*ArkWeb_OnJavaScriptCallback)(
 typedef void (*ArkWeb_OnJavaScriptProxyCallback)(
     const char* webTag, const ArkWeb_JavaScriptBridgeData* dataArray, size_t arraySize, void* userData);
 
+/**
+ * @brief Defines the JavaScript proxy callback of the native ArkWeb.
+ *
+ * @param webTag The name of the web component.
+ * @param dataArray The JavaScript bridge data array from HTML.
+ * @param arraySize The number of elements in the array.
+ * @param userData The data set by user.
+ *
+ * @since 14
+ */
+typedef ArkWeb_JavaScriptValuePtr (*ArkWeb_OnJavaScriptProxyCallbackWithResult)(
+    const char* webTag, const ArkWeb_JavaScriptBridgeData* dataArray, size_t arraySize, void* userData);
+
 /**
  * @brief Defines the component callback of the native ArkWeb.
  *
@@ -148,6 +182,20 @@ typedef struct {
     void* userData;
 } ArkWeb_ProxyMethod;
 
+/**
+ * @brief Defines the JavaScript proxy method with a return value.
+ *
+ * @since 14
+ */
+typedef struct {
+    /** The method of the application side JavaScript object participating in the registration. */
+    const char* methodName;
+    /** The callback function with a return value registered by developer is called back when HTML side uses. */
+    ArkWeb_OnJavaScriptProxyCallbackWithResult callback;
+    /** The user data to set. */
+    void* userData;
+} ArkWeb_ProxyMethodWithResult;
+
 /**
  * @brief Defines the javascript proxy registered object.
  *
@@ -162,6 +210,20 @@ typedef struct {
     size_t size;
 } ArkWeb_ProxyObject;
 
+/**
+ * @brief Defines the JavaScript proxy registered object with methodList that has a return value.
+ *
+ * @since 14
+ */
+typedef struct {
+    /** The name of the registered object. */
+    const char* objName;
+    /** The JavaScript proxy registered method object list with a callback function that has a return value */
+    const ArkWeb_ProxyMethodWithResult* methodList;
+    /** The size of the methodList. */
+    size_t size;
+} ArkWeb_ProxyObjectWithResult;
+
 /**
  * @brief Defines the controller API for native ArkWeb.
  * Before invoking an API, you are advised to use ARKWEB_MEMBER_MISSING to check
@@ -207,13 +269,48 @@ typedef struct {
      * @param name Name of the message to be sent.
      * @param size The quantity of message ports.
      * @param url Indicates the URI for receiving the message.
-     * @return Web message result code
+     * @return Post web message result code.
      *         {@link ARKWEB_SUCCESS} post web message success.
      *         {@link ARKWEB_INVALID_PARAM} the parameter verification fails.
      *         {@link ARKWEB_INIT_ERROR} no web associated with this webTag.
      */
     ArkWeb_ErrorCode (*postWebMessage)(
         const char* webTag, const char* name, ArkWeb_WebMessagePortPtr* webMessagePorts, size_t size, const char* url);
+
+    /**
+     * @brief Get the url of the last frame that calls the JavaScriptProxy.
+     *        This should be call on the thread which JavaScriptProxy called.
+     *
+     * @return The url of the last frame that calls the JavaScriptProxy.
+     * @since 14
+     */
+    const char* (*getLastJavascriptProxyCallingFrameUrl)();
+
+    /**
+     * @brief Register the JavaScript object and method list, the method is callback function that has a return value.
+     *
+     * @param webTag The name of the web component.
+     * @param proxyObject The JavaScript object to register, the object has callback functions with return value.
+     * @param permission The JSON string, which defaults to null, is used to configure the permission control for
+     * JSBridge, allowing for the definition of URL whitelists at the object and method levels.
+     *
+     * @since 14
+     */
+    void (*registerJavaScriptProxyEx)(const char* webTag, const ArkWeb_ProxyObjectWithResult* proxyObject,
+        const char* permission);
+
+    /**
+     * @brief Register the JavaScript object and async method list.
+     *
+     * @param webTag The name of the web component.
+     * @param proxyObject The JavaScript object to register.
+     * @param permission The JSON string, which defaults to null, is used to configure the permission control
+     * for JSBridge, allowing for the definition of URL whitelists at the object and method levels.
+     *
+     * @since 14
+     */
+    void (*registerAsyncJavaScriptProxyEx)(const char* webTag, const ArkWeb_ProxyObject* proxyObject,
+        const char* permission);
 } ArkWeb_ControllerAPI;
 
 /**
@@ -313,7 +410,7 @@ typedef struct {
      * @param webMessagePort The ArkWeb_WebMessagePort.
      * @param webTag The name of the web component.
      * @param webMessage The ArkWeb_WebMessage to send.
-     * @return Web message result code
+     * @return Post message result code.
      *         {@link ARKWEB_SUCCESS} post message success.
      *         {@link ARKWEB_INVALID_PARAM} the parameter verification fails.
      *         {@link ARKWEB_INIT_ERROR} no web associated with this webTag.
@@ -395,6 +492,30 @@ typedef struct {
     void* (*getData)(ArkWeb_WebMessagePtr webMessage, size_t* dataLength);
 } ArkWeb_WebMessageAPI;
 
+/**
+ * @brief Defines the native JavaScriptValue API for ArkWeb.
+ * Before invoking an API, you are advised to use ARKWEB_MEMBER_MISSING to check
+ * whether the function structure has a corresponding function pointer to avoid crash
+ * caused by mismatch between the SDK and the device ROM.
+ *
+ * @since 14
+ */
+typedef struct {
+    /** The ArkWeb_JavaScriptValueAPI struct size. */
+    size_t size;
+
+    /**
+     * @brief Create the JavaScript value responding to HTML.
+     *
+     * @param type The type of ArkWeb_JavaScriptValue.
+     * @param data The data buffer of ArkWeb_JavaScriptValue.
+     * @param dataLength The length of data buffer.
+     * @return ArkWeb_JavaScriptValuePtr created by ArkWeb, the memory of ArkWeb_JavaScriptValue
+     * is managed by ArkWeb itself.
+     */
+    ArkWeb_JavaScriptValuePtr (*createJavaScriptValue)(ArkWeb_JavaScriptValueType type, void* data, size_t dataLength);
+} ArkWeb_JavaScriptValueAPI;
+
 /**
  * @brief Check whether the member variables of the current struct exist.
  *
diff --git a/ohos_nweb/src/cef_delegate/nweb_delegate.cc b/ohos_nweb/src/cef_delegate/nweb_delegate.cc
index ffc4cdd39c4f97068fc61546799f18e808ca4ee0..a47a3138084ff09d559472ffad2bb9c977f53f4e 100644
--- a/ohos_nweb/src/cef_delegate/nweb_delegate.cc
+++ b/ohos_nweb/src/cef_delegate/nweb_delegate.cc
@@ -2003,8 +2003,8 @@ void NWebDelegate::RegisterArkJSfunction(
       LOG(INFO) << "NWebDelegate::RegisterArkJSfunction popup case, the "
                    "object_name is "
                 << object_name.c_str();
-      handler_delegate_->SavaArkJSFunctionForPopup(object_name, method_list,
-                                                   async_method_list, object_id, permission);
+      handler_delegate_->SavaArkJSFunctionForPopup(
+          object_name, method_list, async_method_list, object_id, permission);
     }
     return;
   } else if (!GetBrowser()) {
@@ -2013,8 +2013,8 @@ void NWebDelegate::RegisterArkJSfunction(
                << object_name.c_str();
     return;
   } else {
-    GetBrowser()->GetHost()->RegisterArkJSfunction(object_name, method_vector,
-                                                   async_method_vector, object_id, permission);
+    GetBrowser()->GetHost()->RegisterArkJSfunction(
+        object_name, method_vector, async_method_vector, object_id, permission);
   }
 }
 
@@ -2039,10 +2039,11 @@ void NWebDelegate::UnregisterArkJSfunction(
 
 void NWebDelegate::RegisterNativeArkJSFunction(
     const char* objName,
-    const std::vector<std::shared_ptr<NWebJsProxyCallback>> &callbacks) {
+    const std::vector<std::shared_ptr<NWebJsProxyCallback>>& callbacks) {
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(CEF_UIT,
-      base::BindOnce(&NWebDelegate::RegisterNativeArkJSFunction, this, objName, callbacks));
+                  base::BindOnce(&NWebDelegate::RegisterNativeArkJSFunction,
+                                 this, objName, callbacks));
     return;
   }
 
@@ -2053,7 +2054,8 @@ void NWebDelegate::RegisterNativeArkJSFunction(
   }
   if (GetBrowser() && GetBrowser()->GetHost()) {
     GetBrowser()->GetHost()->RegisterArkJSfunction(objName, method_vector,
-                                                   std::vector<CefString>(), kDefaultWebNativeProxy, "");
+                                                   std::vector<CefString>(),
+                                                   kDefaultWebNativeProxy, "");
   } else {
     LOG(ERROR) << "browser or host is null";
   }
@@ -2066,10 +2068,48 @@ void NWebDelegate::RegisterNativeJSProxy(
                                     std::vector<size_t>&)>>&& callback,
     bool isAsync,
     const std::string& permission) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(&NWebDelegate::RegisterNativeJSProxy, this, objName,
+                       methodName, std::move(callback), isAsync, permission));
+    return;
+  }
+
+  if (handler_delegate_ == nullptr) {
+    LOG(ERROR) << "handler_delegate_ is nullptr";
+    return;
+  }
+
+  handler_delegate_->RegisterNativeJavaScriptCallBack(
+      objName, methodName, std::move(callback), isAsync, permission);
+
+  size_t size = methodName.size();
+  std::vector<CefString> method_vector;
+  for (size_t i = 0; i < size; i++) {
+    method_vector.push_back(methodName[i]);
+  }
+  if (GetBrowser() && GetBrowser()->GetHost()) {
+    GetBrowser()->GetHost()->RegisterNativeJSProxy(
+        objName, method_vector, kDefaultWebNativeProxy, isAsync, permission);
+  } else {
+    LOG(ERROR) << "browser or host is null";
+  }
+}
+
+void NWebDelegate::RegisterNativeJSProxyWithResult(
+    const std::string& objName,
+    const std::vector<std::string>& methodName,
+    std::vector<std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+        std::vector<std::vector<uint8_t>>&,
+        std::vector<size_t>&)>>&& callback,
+    bool isAsync,
+    const std::string& permission) {
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(CEF_UIT,
-                  base::BindOnce(&NWebDelegate::RegisterNativeJSProxy, this,
-                                 objName, methodName, std::move(callback), isAsync, permission));
+                  base::BindOnce(&NWebDelegate::RegisterNativeJSProxyWithResult,
+                                 this, objName, methodName, std::move(callback),
+                                 isAsync, permission));
     return;
   }
 
@@ -2078,8 +2118,8 @@ void NWebDelegate::RegisterNativeJSProxy(
     return;
   }
 
-  handler_delegate_->RegisterNativeJavaScriptCallBack(objName, methodName,
-                                                      std::move(callback), isAsync, permission);
+  handler_delegate_->RegisterNativeJavaScriptCallBackWithResult(
+      objName, methodName, std::move(callback), isAsync, permission);
 
   size_t size = methodName.size();
   std::vector<CefString> method_vector;
@@ -2087,8 +2127,8 @@ void NWebDelegate::RegisterNativeJSProxy(
     method_vector.push_back(methodName[i]);
   }
   if (GetBrowser() && GetBrowser()->GetHost()) {
-    GetBrowser()->GetHost()->RegisterNativeJSProxy(objName, method_vector,
-                                                   kDefaultWebNativeProxy, isAsync, permission);
+    GetBrowser()->GetHost()->RegisterNativeJSProxy(
+        objName, method_vector, kDefaultWebNativeProxy, isAsync, permission);
   } else {
     LOG(ERROR) << "browser or host is null";
   }
@@ -2097,7 +2137,8 @@ void NWebDelegate::RegisterNativeJSProxy(
 void NWebDelegate::UnRegisterNativeArkJSFunction(const char* objName) {
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(CEF_UIT,
-      base::BindOnce(&NWebDelegate::UnRegisterNativeArkJSFunction, this, objName));
+                  base::BindOnce(&NWebDelegate::UnRegisterNativeArkJSFunction,
+                                 this, objName));
     return;
   }
 
@@ -2130,7 +2171,7 @@ void NWebDelegate::RegisterNativeLoadEndCallback(
 void NWebDelegate::JavaScriptOnDocumentStart(const ScriptItems& scriptItems) {
   if (GetBrowser() != nullptr && GetBrowser()->GetHost() != nullptr) {
     GetBrowser()->GetHost()->RemoveJavaScriptOnDocumentStart();
-    for (auto item: scriptItems) {
+    for (auto item : scriptItems) {
       CefString script = item.first;
       std::vector<CefString> scriptRules;
       for (std::string rule : item.second) {
@@ -2173,7 +2214,7 @@ void NWebDelegate::CallH5Function(
 void NWebDelegate::JavaScriptOnDocumentEnd(const ScriptItems& scriptItems) {
   if (GetBrowser() != nullptr && GetBrowser()->GetHost() != nullptr) {
     GetBrowser()->GetHost()->RemoveJavaScriptOnDocumentEnd();
-    for (auto item: scriptItems) {
+    for (auto item : scriptItems) {
       CefString script = item.first;
       std::vector<CefString> scriptRules;
       for (std::string rule : item.second) {
diff --git a/ohos_nweb/src/cef_delegate/nweb_delegate.h b/ohos_nweb/src/cef_delegate/nweb_delegate.h
index ced7b49d93a0f2680128367abbde330e61add474..6e670aebca4c23c04fa910f7039229c2776d13c5 100644
--- a/ohos_nweb/src/cef_delegate/nweb_delegate.h
+++ b/ohos_nweb/src/cef_delegate/nweb_delegate.h
@@ -173,6 +173,12 @@ class NWebDelegate : public NWebDelegateInterface, public virtual CefRefCount {
       std::vector<std::function<char*(std::vector<std::vector<uint8_t>>&,
                                       std::vector<size_t>&)>>&& callback,
       bool isAsync, const std::string& permission) override;
+  void RegisterNativeJSProxyWithResult(
+      const std::string& objName,
+      const std::vector<std::string>& methodName,
+      std::vector<std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+          std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)>>&& callback,
+      bool isAsync, const std::string& permission) override;
   void UnRegisterNativeArkJSFunction(const char* objName) override;
   void RegisterNativeLoadStartCallback(
       std::function<void(void)>&& callback) override;
diff --git a/ohos_nweb/src/cef_delegate/nweb_handler_delegate.cc b/ohos_nweb/src/cef_delegate/nweb_handler_delegate.cc
index 296d3be358bf23c0be41156c86860416252329c6..9d21b01fb1943fadc68f39f501d12866e8c4a547 100644
--- a/ohos_nweb/src/cef_delegate/nweb_handler_delegate.cc
+++ b/ohos_nweb/src/cef_delegate/nweb_handler_delegate.cc
@@ -369,6 +369,43 @@ bool AllowCookies(const GURL& url,
   return net::StaticCookiePolicy(policy).CanAccessCookies(
              url, site_for_cookies) == net::OK;
 }
+
+void ParseNativeProxyArgs(CefRefPtr<CefListValue> args,
+                          std::vector<std::vector<uint8_t>>& dataList,
+                          std::vector<size_t>& dataSize) {
+  size_t argsSize = args->GetSize();
+
+  for (size_t i = 0; i < argsSize; i++) {
+    CefValueType type = args->GetType(i);
+    CefRefPtr<CefValue> value = args->GetValue(i);
+    if (!value) {
+      LOG(ERROR) << "value is nullptr";
+      continue;
+    }
+
+    if (type == VTYPE_STRING) {
+      auto argString = value->GetString().ToString();
+      size_t size = argString.size();
+
+      dataList[i] = std::vector<uint8_t>(argString.begin(), argString.end());
+      dataSize[i] = size;
+    } else if (type == VTYPE_BINARY) {
+      auto argBinary = value->GetBinary();
+      size_t size = argBinary->GetSize();
+
+      std::vector<uint8_t> data(size);
+      argBinary->GetData(&data[0], size, 0);
+
+      dataList[i] = std::move(data);
+      dataSize[i] = size;
+    } else {
+      std::string jsonString =
+          CefWriteJSON(value, JSON_WRITER_OMIT_BINARY_VALUES);
+      dataList[i] = std::vector<uint8_t>(jsonString.begin(), jsonString.end());
+      dataSize[i] = jsonString.size();
+    }
+  }
+}
 }  // namespace
 
 class NWebDateTimeSuggestionImpl : public NWebDateTimeSuggestion {
@@ -2062,7 +2099,7 @@ void NWebHandlerDelegate::OnAdsBlocked(
     adsBlocked_str.insert({item.first, num});
   }
   LOG(DEBUG) << "[adblock] OnAdsBlocked size: " << adsBlocked_str.size()
-             << "  url = ***"; 
+             << "  url = ***";
 
   if (web_app_client_extension_listener_ != nullptr &&
       web_app_client_extension_listener_->OnAdsBlocked != nullptr) {
@@ -2146,7 +2183,7 @@ void NWebHandlerDelegate::OnReceivedIcon(const void* data,
 #ifdef OHOS_BFCACHE
 void NWebHandlerDelegate::UpdateFavicon(CefRefPtr<CefBrowser> browser) {
   CEF_REQUIRE_UI_THREAD();
- 
+
   void* data = nullptr;
   int color_type;
   int alpha_type;
@@ -3116,14 +3153,55 @@ void NWebHandlerDelegate::RegisterNativeJavaScriptCallBack(
     map[methodName[i]] = callback[i];
   }
   if (isAsync) {
+    if (auto async_it = asyncProxyObjWithResultMap_.find(objName);
+      async_it != asyncProxyObjWithResultMap_.end()) {
+      asyncProxyObjWithResultMap_.erase(objName);
+    }
     asyncProxyObjMap_[objName] = map;
     asyncProxyPermissionMap_[objName] = permission;
   } else {
+    if (auto async_it = syncProxyObjWithResultMap_.find(objName);
+      async_it != syncProxyObjWithResultMap_.end()) {
+      syncProxyObjWithResultMap_.erase(objName);
+    }
     syncProxyObjMap_[objName] = map;
     syncProxyPermissionMap_[objName] = permission;
   }
 }
 
+void NWebHandlerDelegate::RegisterNativeJavaScriptCallBackWithResult(
+    const std::string& objName,
+    const std::vector<std::string>& methodName,
+    std::vector<NativeJSProxyCallbackFuncWithResult>&& callback,
+    bool isAsync,
+    const std::string& permission) {
+  size_t size = methodName.size();
+  if (size == 0) {
+    LOG(ERROR) << "NWebHandlerDelegate RegisterNativeJavaScriptCallBack error: "
+                  "empty methods list";
+    return;
+  }
+  std::unordered_map<std::string, NativeJSProxyCallbackFuncWithResult> map;
+  for (size_t i = 0; i < size; i++) {
+    map[methodName[i]] = callback[i];
+  }
+  if (isAsync) {
+    if (auto async_it = asyncProxyObjMap_.find(objName);
+        async_it != asyncProxyObjMap_.end()) {
+      asyncProxyObjMap_.erase(objName);
+    }
+    asyncProxyObjWithResultMap_[objName] = map;
+    asyncProxyPermissionMap_[objName] = permission;
+  } else {
+    if (auto sync_it = syncProxyObjMap_.find(objName);
+        sync_it != syncProxyObjMap_.end()) {
+      syncProxyObjMap_.erase(objName);
+    }
+    syncProxyObjWithResultMap_[objName] = map;
+    syncProxyPermissionMap_[objName] = permission;
+  }
+}
+
 int NWebHandlerDelegate::ProcessNativeProxyResultThread(
     CefRefPtr<CefListValue> args,
     const CefString& method,
@@ -3186,6 +3264,7 @@ int NWebHandlerDelegate::ProcessNativeProxyResultNew(
   }
 
   NativeJSProxyCallbackFunc callback = nullptr;
+
   auto it = asyncProxyObjMap_.find(object_name);
   if (it != asyncProxyObjMap_.end()) {
     auto& methodMap = it->second;
@@ -3219,42 +3298,70 @@ int NWebHandlerDelegate::ProcessNativeProxyResultNew(
   std::vector<std::vector<uint8_t>> dataList(argsSize);
   std::vector<size_t> dataSize(argsSize);
 
-  for (size_t i = 0; i < argsSize; i++) {
-    CefValueType type = args->GetType(i);
-    CefRefPtr<CefValue> value = args->GetValue(i);
-    if (!value) {
-      LOG(ERROR) << "value is nullptr";
-      continue;
-    }
+  ParseNativeProxyArgs(args, dataList, dataSize);
 
-    if (type == VTYPE_STRING) {
-      auto argString = value->GetString().ToString();
-      size_t size = argString.size();
+  char* callbackResult = callback(dataList, dataSize);
+  if (callbackResult) {
+    result->SetString(0, callbackResult);
+  } else {
+    LOG(INFO) << "native return nullptr, just set null string to result";
+    result->SetNull(0);
+  }
+  return 0;
+}
 
-      dataList[i] = std::vector<uint8_t>(argString.begin(), argString.end());
-      dataSize[i] = size;
-    } else if (type == VTYPE_BINARY) {
-      auto argBinary = value->GetBinary();
-      size_t size = argBinary->GetSize();
+int NWebHandlerDelegate::ProcessNativeProxyResultNewForReturnValue(
+    CefRefPtr<CefListValue> args,
+    const CefString& method,
+    const CefString& object_name,
+    CefRefPtr<CefListValue> result) {
+  if (!args) {
+    LOG(ERROR) << "args is nullptr";
+    return 1;
+  }
 
-      std::vector<uint8_t> data(size);
-      argBinary->GetData(&data[0], size, 0);
+  NativeJSProxyCallbackFuncWithResult CallbackWithResult = nullptr;
 
-      dataList[i] = std::move(data);
-      dataSize[i] = size;
-    } else {
-      std::string jsonString =
-          CefWriteJSON(value, JSON_WRITER_OMIT_BINARY_VALUES);
-      dataList[i] = std::vector<uint8_t>(jsonString.begin(), jsonString.end());
-      dataSize[i] = jsonString.size();
+  if (auto iter = asyncProxyObjWithResultMap_.find(object_name);
+      iter != asyncProxyObjWithResultMap_.end()) {
+    auto& methodMap = iter->second;
+    auto methodIt = methodMap.find(method);
+    if (methodIt != methodMap.end()) {
+      LOG(DEBUG) << "Processing async native proxy result, "
+                 << "method name: " << method.ToString();
+      CallbackWithResult = methodMap[method];
     }
   }
 
-  char* callbackResult = callback(dataList, dataSize);
+  if (CallbackWithResult == nullptr) {
+    auto iter = syncProxyObjWithResultMap_.find(object_name);
+    if (iter != syncProxyObjWithResultMap_.end()) {
+      auto& methodMap = iter->second;
+      auto methodIt = methodMap.find(method);
+      if (methodIt != methodMap.end()) {
+        LOG(DEBUG) << "Processing sync native proxy result, "
+                   << "method name: " << method.ToString();
+        CallbackWithResult = methodMap[method];
+      }
+    }
+  }
+
+  if (CallbackWithResult == nullptr) {
+    LOG(DEBUG) << "Processing native proxy result failed, "
+               << "method not found, name: "
+               << method.ToString();
+    return 1;
+  }
+  size_t argsSize = args->GetSize();
+  std::vector<std::vector<uint8_t>> dataList(argsSize);
+  std::vector<size_t> dataSize(argsSize);
+  ParseNativeProxyArgs(args, dataList, dataSize);
+
+  std::shared_ptr<OHOS::NWeb::NWebValue> callbackResult = CallbackWithResult(dataList, dataSize);
   if (callbackResult) {
-    result->SetString(0, callbackResult);
+    ParseNWebValueToValue(callbackResult, result);
   } else {
-    LOG(INFO) << "native return nullptr, just set null string to result";
+    LOG(DEBUG) << "native return nullptr, just set null string to result";
     result->SetNull(0);
   }
 
@@ -3266,11 +3373,29 @@ int NWebHandlerDelegate::ProcessNativeProxyResult(
     const CefString& method,
     const CefString& object_name,
     CefRefPtr<CefListValue> result) {
-  if (auto it = syncProxyObjMap_.find(object_name); it != syncProxyObjMap_.end()) {
-    ProcessNativeProxyResultNew(args, method, object_name, result);
+  if (auto it = syncProxyObjWithResultMap_.find(object_name); it != syncProxyObjWithResultMap_.end()) {
+    if (ProcessNativeProxyResultNew(args, method, object_name, result) == 1) {
+      ProcessNativeProxyResultNewForReturnValue(args, method, object_name, result);
+    }
+    return 0;
+  } else if (auto async_it = asyncProxyObjWithResultMap_.find(object_name);
+      async_it != asyncProxyObjWithResultMap_.end()) {
+    if (ProcessNativeProxyResultNew(args, method, object_name, result) == 1) {
+      ProcessNativeProxyResultNewForReturnValue(args, method, object_name,
+                                                result);
+    }
+    return 0;
+  } else if (auto it_with_result = syncProxyObjMap_.find(object_name); it_with_result != syncProxyObjMap_.end()) {
+    if (ProcessNativeProxyResultNew(args, method, object_name, result) == 1) {
+      ProcessNativeProxyResultNewForReturnValue(args, method, object_name,
+                                                result);
+    }
     return 0;
-  } else if (auto async_it = asyncProxyObjMap_.find(object_name); async_it != asyncProxyObjMap_.end()) {
-    ProcessNativeProxyResultNew(args, method, object_name, result);
+  } else if (auto async_it_with_result = asyncProxyObjMap_.find(object_name);
+      async_it_with_result != asyncProxyObjMap_.end()) {
+    if (ProcessNativeProxyResultNew(args, method, object_name, result) == 1) {
+      ProcessNativeProxyResultNewForReturnValue(args, method, object_name, result);
+    }
     return 0;
   }
 
diff --git a/ohos_nweb/src/cef_delegate/nweb_handler_delegate.h b/ohos_nweb/src/cef_delegate/nweb_handler_delegate.h
index 1a91dd98a6d0a59622f5088a444ec18effddce37..b28b88f186282d474f1a1c19427b9a0e12bed22c 100644
--- a/ohos_nweb/src/cef_delegate/nweb_handler_delegate.h
+++ b/ohos_nweb/src/cef_delegate/nweb_handler_delegate.h
@@ -134,12 +134,22 @@ class NWebHandlerDelegate : public CefClient,
   using NativeJSProxyCallbackFunc =
       std::function<char*(std::vector<std::vector<uint8_t>>&,
                           std::vector<size_t>&)>;
+  using NativeJSProxyCallbackFuncWithResult =
+      std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+          std::vector<std::vector<uint8_t>>&,
+          std::vector<size_t>&)>;
   void RegisterNativeJavaScriptCallBack(
       const std::string& objName,
       const std::vector<std::string>& methodName,
       std::vector<NativeJSProxyCallbackFunc>&& callback,
       bool isAsync,
       const std::string& permission);
+  void RegisterNativeJavaScriptCallBackWithResult(
+      const std::string& objName,
+      const std::vector<std::string>& methodName,
+      std::vector<NativeJSProxyCallbackFuncWithResult>&& callback,
+      bool isAsync,
+      const std::string& permission);
   void RegisterNativeLoadStartCallback(std::function<void(void)>&& callback);
   void RegisterNativeLoadEndCallback(std::function<void(void)>&& callback);
   int GetFlowbufCount(void* mem);
@@ -148,7 +158,10 @@ class NWebHandlerDelegate : public CefClient,
                                   const CefString& method,
                                   const CefString& object_name,
                                   CefRefPtr<CefListValue> result);
-
+  int ProcessNativeProxyResultNewForReturnValue(CefRefPtr<CefListValue> args,
+                                  const CefString& method,
+                                  const CefString& object_name,
+                                  CefRefPtr<CefListValue> result);
   int ProcessNativeProxyResultNewFlowbuf(CefRefPtr<CefListValue> args,
                                   const CefString& method,
                                   const CefString& object_name,
@@ -705,11 +718,12 @@ bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,
   // #endif
 
   // save ark js function for window.open
-  void SavaArkJSFunctionForPopup(const std::string& object_name,
-                                 const std::vector<std::string>& method_list,
-                                 const std::vector<std::string>& async_method_list,
-                                 const int32_t object_id,
-                                 const std::string& permission);
+  void SavaArkJSFunctionForPopup(
+      const std::string& object_name,
+      const std::vector<std::string>& method_list,
+      const std::vector<std::string>& async_method_list,
+      const int32_t object_id,
+      const std::string& permission);
 #ifdef OHOS_DRAG_DROP
   bool IsDragEnter() const { return is_drag_enter_; }
   void SetDragEnter(bool enter) { is_drag_enter_ = enter; }
@@ -891,9 +905,17 @@ bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,
   std::unordered_map<std::string,
                      std::unordered_map<std::string, NativeJSProxyCallbackFunc>>
       syncProxyObjMap_;
+  std::unordered_map<
+      std::string,
+      std::unordered_map<std::string, NativeJSProxyCallbackFuncWithResult>>
+      syncProxyObjWithResultMap_;
   std::unordered_map<std::string,
                      std::unordered_map<std::string, NativeJSProxyCallbackFunc>>
       asyncProxyObjMap_;
+  std::unordered_map<
+      std::string,
+      std::unordered_map<std::string, NativeJSProxyCallbackFuncWithResult>>
+      asyncProxyObjWithResultMap_;
   std::unordered_map<std::string, std::string> asyncProxyPermissionMap_;
   std::unordered_map<std::string, std::string> syncProxyPermissionMap_;
   using MethodPair = std::pair<std::string, std::unordered_set<std::string>>;
diff --git a/ohos_nweb/src/ndk/arkweb_model.cc b/ohos_nweb/src/ndk/arkweb_model.cc
index d51045255ebcc35ef8a820284ce4ade0eb8c603a..32392d58d534e2b2b973fbcf46d94ce9658640ba 100644
--- a/ohos_nweb/src/ndk/arkweb_model.cc
+++ b/ohos_nweb/src/ndk/arkweb_model.cc
@@ -28,8 +28,60 @@
 #include "nweb_value_callback.h"
 #include "ohos_nweb/include/nweb_engine.h"
 #include "ohos_nweb/include/nweb_errors.h"
+#include "third_party/bounds_checking_function/include/securec.h"
 
 #ifdef __cplusplus
+
+std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+        std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)> CreateProxyCallback(
+            ArkWeb_OnJavaScriptProxyCallbackWithResult callback, std::string tag, void* data) {
+  return [cb = callback,
+          webTag = std::string(tag),
+          userData = data](
+              std::vector<std::vector<uint8_t>>& dataList,
+              std::vector<size_t>& dataSize) ->
+                std::shared_ptr<OHOS::NWeb::NWebValue> {
+    if (cb) {
+      size_t size = dataList.size();
+      std::vector<ArkWeb_JavaScriptBridgeData> dataVector(size);
+      for (size_t i = 0; i < size; i++) {
+        ArkWeb_JavaScriptBridgeData data = {.buffer = dataList[i].data(),
+                                            .size = dataSize[i]};
+        dataVector[i] = data;
+      }
+      ArkWeb_JavaScriptValuePtr result =
+          cb(webTag.c_str(), dataVector.data(), size, userData);
+      std::shared_ptr<OHOS::NWeb::NWebValue> nwebValue =
+          std::make_shared<OHOS::NWeb::NWebValue>(OHOS::NWeb::NWebValue::Type::NONE);
+      if (!result) {
+        WVLOG_D("native return nullptr");
+        return nullptr;
+      }
+      if (result->type == ArkWeb_JavaScriptValueType::ARKWEB_JAVASCRIPT_BOOL) {
+        WVLOG_D("result is bool type");
+        bool boolVal = (*(bool*)(result->data));
+        delete (bool*)(result->data);
+        delete result;
+        nwebValue->SetType(OHOS::NWeb::NWebValue::Type::BOOLEAN);
+        nwebValue->SetBoolean(boolVal);
+      } else if (result->type == ArkWeb_JavaScriptValueType::ARKWEB_JAVASCRIPT_STRING) {
+        WVLOG_D("result is string type");
+        std::string strVal = std::string(((char*)(result->data)));
+        delete[] (char*)(result->data);
+        delete result;
+        nwebValue->SetType(OHOS::NWeb::NWebValue::Type::STRING);
+        nwebValue->SetString(strVal);
+      } else {
+        WVLOG_D("native return nullptr");
+        return nullptr;
+      }
+      return nwebValue;
+    }
+    WVLOG_D("native return nullptr");
+    return nullptr;
+  };
+}
+
 extern "C" {
 #endif  // __cplusplus
 
@@ -264,9 +316,13 @@ void RegisterJavaScriptProxy(
       };
       callbackList[i] = std::move(proxyCallback);
     }
-
-    nwebSharedPtr->RegisterNativeArkJSFunction(
-      proxyObject->objName, methodNameList, std::move(callbackList), isAsync, permission);
+    if (permission) {
+      nwebSharedPtr->RegisterNativeArkJSFunction(
+        proxyObject->objName, methodNameList, std::move(callbackList), isAsync, permission);
+    } else {
+      nwebSharedPtr->RegisterNativeArkJSFunction(
+        proxyObject->objName, methodNameList, std::move(callbackList), isAsync, "");
+    }
   } else {
     LOG(ERROR)
         << "NativeArkWeb RegisterJavaScriptProxy get nweb null: %{public}s"
@@ -274,26 +330,20 @@ void RegisterJavaScriptProxy(
   }
 }
 
-ARKWEB_NDK_EXPORT void OH_ArkWeb_RegisterJavaScriptProxyEx(const char* webTag,
-                                         const ArkWeb_ProxyObject* proxyObject,
-                                         const char* permission) {
-  RegisterJavaScriptProxy(webTag,
-                          proxyObject, false,
-                          permission);
-}
-
-ARKWEB_NDK_EXPORT ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(
+bool CreateWebMessagePortsInternal(
     const char* webTag,
-    size_t* size) {
+    size_t* size,
+    std::vector<std::string>& ports,
+    ArkWeb_WebMessagePortPtr** wPortsResult) {
   if (!webTag || !size) {
     LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts nullptr error";
-    return nullptr;
+    return false;
   }
 
   if (std::string(webTag).empty()) {
     LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts web tag empty";
     *size = 0;
-    return nullptr;
+    return false;
   }
 
   auto webObjectPtr =
@@ -301,7 +351,7 @@ ARKWEB_NDK_EXPORT ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(
   if (!webObjectPtr) {
     LOG(ERROR) << "NativeArkWeb object pointer is nullptr";
     *size = 0;
-    return nullptr;
+    return false;
   }
 
   auto nwebSharedPtr = webObjectPtr->GetWebSharedPtr();
@@ -309,14 +359,14 @@ ARKWEB_NDK_EXPORT ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(
     LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts get nweb null: %{public}s"
                << webTag;
     *size = 0;
-    return nullptr;
+    return false;
   }
 
-  std::vector<std::string> ports = nwebSharedPtr->CreateWebMessagePorts();
+  ports = nwebSharedPtr->CreateWebMessagePorts();
   if (ports.size() == 0) {
     LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts failed";
     *size = 0;
-    return nullptr;
+    return false;
   }
 
   ArkWeb_WebMessagePortPtr* wPorts =
@@ -324,38 +374,58 @@ ARKWEB_NDK_EXPORT ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(
   if (!wPorts) {
     LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc failed";
     *size = 0;
+    return false;
+  }
+  *wPortsResult = wPorts;
+  return true;
+}
+
+ARKWEB_NDK_EXPORT ArkWeb_WebMessagePortPtr* OH_ArkWeb_CreateWebMessagePorts(
+    const char* webTag,
+    size_t* size) {
+  std::vector<std::string> ports;
+  ArkWeb_WebMessagePortPtr* wPorts;
+  if (!CreateWebMessagePortsInternal(webTag, size, ports, &wPorts)) {
     return nullptr;
   }
+  auto webObjectPtr = OHOS::NWeb::ArkWebNativeObject::GetWebInstanceByWebTag(webTag);
   for (unsigned int i = 0; i < ports.size(); i++) {
     wPorts[i] = new (std::nothrow) ArkWeb_WebMessagePort();
     if (!wPorts[i]) {
       LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc failed";
-      nwebSharedPtr->ClosePort(std::string(ports[0]));
+      webObjectPtr->GetWebSharedPtr()->ClosePort(std::string(ports[0]));
       OH_ArkWeb_DestroyWebMessagePorts(&wPorts, ports.size());
       *size = 0;
       return nullptr;
     }
 
     char* tag = new (std::nothrow) char[std::string(webTag).size() + 1];
-    if (!tag) {
-      LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc failed";
-      nwebSharedPtr->ClosePort(std::string(ports[0]));
+    if (!tag || memcpy_s(tag, std::string(webTag).size() + 1,
+        (char*)webTag, std::string(webTag).size() + 1) != EOK) {
+      LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc or memcpy failed";
+      if (tag) {
+        delete[] tag;
+      }
+      webObjectPtr->GetWebSharedPtr()->ClosePort(std::string(ports[0]));
       OH_ArkWeb_DestroyWebMessagePorts(&wPorts, ports.size());
       *size = 0;
       return nullptr;
     }
-    memcpy(tag, (char*)webTag, std::string(webTag).size() + 1);
+
     wPorts[i]->webTag = tag;
 
     char* portHandle = new (std::nothrow) char[ports[i].size() + 1];
-    if (!portHandle) {
-      LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc failed";
-      nwebSharedPtr->ClosePort(std::string(ports[0]));
+    if (!portHandle ||
+        memcpy_s(portHandle, ports[i].size() + 1, (char*)(ports[i].c_str()), ports[i].size() + 1) != EOK) {
+      LOG(ERROR) << "NativeArkWeb CreateWebMessagePorts malloc or memcpy failed";
+      if (portHandle) {
+        delete[] portHandle;
+      }
+      webObjectPtr->GetWebSharedPtr()->ClosePort(std::string(ports[0]));
       OH_ArkWeb_DestroyWebMessagePorts(&wPorts, ports.size());
       *size = 0;
       return nullptr;
     }
-    memcpy(portHandle, (char*)(ports[i].c_str()), ports[i].size() + 1);
     wPorts[i]->portHandle = portHandle;
   }
   *size = ports.size();
@@ -641,7 +711,12 @@ ARKWEB_NDK_EXPORT void OH_WebMessage_SetData(ArkWeb_WebMessagePtr message,
     return;
   }
 
-  memcpy(destination, (char*)data, dataLength);
+  if (memcpy_s(destination, dataLength, (char*)data, dataLength) != EOK) {
+    LOG(ERROR) << "NativeArkWeb SetData memcpy failed";
+    delete[] destination;
+    return;
+  }
+
   message->data = (void*)destination;
   message->dataLength = dataLength;
 }
@@ -675,7 +750,7 @@ ARKWEB_NDK_EXPORT ArkWeb_ErrorCode OH_CookieManager_FetchCookieSync(
   *cookie_value = new char[cookie_content.length() + 1];
   strcpy((*cookie_value), cookie_content.c_str());
   if (cookie_content == "" && !is_valid) {
-    return ARKWEB_INVALID_URL; 
+    return ARKWEB_INVALID_URL;
   }
 
   return ARKWEB_SUCCESS;
@@ -729,6 +804,133 @@ ARKWEB_NDK_EXPORT void OH_CookieManager_ClearSessionCookiesSync() {
   cookie_manager->DeleteSessionCookies(nullptr);
 }
 
+void RegisterJavaScriptProxyEx(
+    const char* webTag,
+    const ArkWeb_ProxyObjectWithResult* proxyObject,
+    bool isAsync,
+    const char* permission) {
+  if (proxyObject == nullptr) {
+    LOG(ERROR) << "NativeArkWeb proxy object is nullptr";
+    return;
+  }
+
+  if (proxyObject->objName == nullptr) {
+    LOG(ERROR) << "NativeArkWeb proxy object name is nullptr";
+    return;
+  }
+
+  auto webObjectPtr =
+      OHOS::NWeb::ArkWebNativeObject::GetWebInstanceByWebTag(webTag);
+  if (!webObjectPtr) {
+    LOG(ERROR) << "NativeArkWeb object pointer is nullptr";
+    return;
+  }
+
+  if (auto nwebSharedPtr = webObjectPtr->GetWebSharedPtr()) {
+    int32_t size = proxyObject->size;
+    std::vector<std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+        std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)>>
+            callbackList(size);
+    const ArkWeb_ProxyMethodWithResult* methodList = proxyObject->methodList;
+    if (methodList == nullptr) {
+      LOG(ERROR) << "NativeArkWeb method list is nullptr";
+      return;
+    }
+
+    std::vector<std::string> methodNameList(size);
+    for (int32_t i = 0; i < size; i++) {
+      auto methodNameObject = methodList[i];
+      methodNameList[i] = methodNameObject.methodName;
+      auto proxyCallback = CreateProxyCallback(
+            methodNameObject.callback, std::string(webTag), methodNameObject.userData);
+      callbackList[i] = std::move(proxyCallback);
+    }
+    if (permission) {
+      nwebSharedPtr->RegisterNativeArkJSFunctionWithResult(
+        proxyObject->objName, methodNameList, std::move(callbackList), isAsync, permission);
+    } else {
+      nwebSharedPtr->RegisterNativeArkJSFunctionWithResult(
+        proxyObject->objName, methodNameList, std::move(callbackList), isAsync, "");
+    }
+  } else {
+    LOG(ERROR)
+        << "NativeArkWeb RegisterJavaScriptProxy get nweb null: %{public}s"
+        << webTag;
+  }
+}
+
+ARKWEB_NDK_EXPORT void OH_ArkWeb_RegisterJavaScriptProxyEx(
+    const char* webTag,
+    const ArkWeb_ProxyObjectWithResult* proxyObject,
+    const char* permission) {
+  if (!webTag || !proxyObject) {
+    return;
+  }
+
+  RegisterJavaScriptProxyEx(webTag, proxyObject, false, permission);
+}
+
+ARKWEB_NDK_EXPORT void OH_ArkWeb_RegisterAsyncJavaScriptProxyEx(
+    const char* webTag,
+    const ArkWeb_ProxyObject* proxyObject,
+    const char* permission) {
+  if (!webTag || !proxyObject) {
+    return;
+  }
+
+  RegisterJavaScriptProxy(webTag, proxyObject, true, permission);
+}
+
+ARKWEB_NDK_EXPORT ArkWeb_JavaScriptValuePtr OH_JavaScript_CreateJavaScriptValue(
+  ArkWeb_JavaScriptValueType type, void* data, size_t dataLength) {
+  ArkWeb_JavaScriptValuePtr value = new (std::nothrow) ArkWeb_JavaScriptValue();
+  if (!value) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue malloc failed";
+    return nullptr;
+  }
+
+  if (!data) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue nullptr error";
+    return nullptr;
+  }
+
+  if (dataLength == 0) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue data size error";
+    return nullptr;
+  }
+
+  if (type == ArkWeb_JavaScriptValueType::ARKWEB_JAVASCRIPT_NONE) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue type none";
+    return nullptr;
+  }
+
+  if (type == ArkWeb_JavaScriptValueType::ARKWEB_JAVASCRIPT_BOOL &&
+      dataLength != 1) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue type bool length error";
+    return nullptr;
+  }
+
+  char* destination = new (std::nothrow) char[dataLength];
+
+  if (!destination) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue malloc failed";
+    delete value;
+    return nullptr;
+  }
+
+  if (memcpy_s(destination, dataLength, (char*)data, dataLength) != EOK) {
+    LOG(ERROR) << "NativeArkWeb CreateJavaScriptValue memcpy failed";
+    delete[] destination;
+    delete value;
+    return nullptr;
+  }
+
+  value->data = (void*)destination;
+  value->dataLength = dataLength;
+  value->type = type;
+
+  return value;
+}
 #ifdef __cplusplus
 }
 #endif  // __cplusplus
diff --git a/ohos_nweb/src/nweb_delegate_interface.h b/ohos_nweb/src/nweb_delegate_interface.h
index 1df2b5ad4f04ca7cbb7482bfd7d1da14ecf33101..55d82fee8168af19434cb561f3b1908e7dbc3a8f 100644
--- a/ohos_nweb/src/nweb_delegate_interface.h
+++ b/ohos_nweb/src/nweb_delegate_interface.h
@@ -230,6 +230,12 @@ class NWebDelegateInterface
                                       std::vector<size_t>&)>>&& callback,
                                       bool isAsync,
                                       const std::string& permission) = 0;
+  virtual void RegisterNativeJSProxyWithResult(
+      const std::string& objName,
+      const std::vector<std::string>& methodName,
+      std::vector<std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+          std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)>>&& callback,
+      bool isAsync, const std::string& permission) = 0;
   virtual void UnRegisterNativeArkJSFunction(const char* objName) = 0;
 
 #ifdef OHOS_ARKWEB_ADBLOCK
@@ -430,23 +436,18 @@ class NWebDelegateInterface
 #if defined(OHOS_INPUT_EVENTS)
   virtual void SetVirtualKeyBoardArg(int32_t width, int32_t height, double keyboard) = 0;
   virtual bool ShouldVirtualKeyboardOverlay() = 0;
-  virtual void WebSendMouseWheelEvent(double x,
-                                      double y,
-                                      double deltaX,
-                                      double deltaY,
+  virtual void WebSendMouseWheelEvent(double x, double y,
+                                      double deltaX, double deltaY,
                                       const std::vector<int32_t>& pressedCodes) = 0;
-  virtual void WebSendTouchpadFlingEvent(double x,
-                                         double y,
-                                         double vx,
-                                         double vy,
+  virtual void WebSendTouchpadFlingEvent(double x, double y,
+                                         double vx, double vy,
                                          const std::vector<int32_t>& pressedCodes) = 0;
 #endif
 
 #if BUILDFLAG(IS_OHOS)
   virtual bool IsSafeBrowsingEnabled() = 0;
   virtual void EnableSafeBrowsing(bool enable) = 0;
-  virtual void PrecompileJavaScript(const std::string& url,
-                                    const std::string& script,
+  virtual void PrecompileJavaScript(const std::string& url, const std::string& script,
                                     std::shared_ptr<CacheOptions>& cacheOptions,
                                     std::shared_ptr<NWebMessageValueCallback> callback) = 0;
 #endif
@@ -558,7 +559,7 @@ virtual int ScaleGestureChange(double scale, double centerX, double centerY) con
   virtual void SetSurfaceDensity(const double& density) = 0;
 
 #ifdef OHOS_MIXED_CONTENT
-  virtual void EnableMixedContentAutoUpgrades(bool enable) = 0; 
+  virtual void EnableMixedContentAutoUpgrades(bool enable) = 0;
   virtual bool IsMixedContentAutoUpgradesEnabled() = 0;
 #endif
 
diff --git a/ohos_nweb/src/nweb_impl.cc b/ohos_nweb/src/nweb_impl.cc
index 5a24004c4ec7c68f516a46c6ab167ac2dcdcd949..6ad6745453d8d4e58002c38d30dfca656426a557 100644
--- a/ohos_nweb/src/nweb_impl.cc
+++ b/ohos_nweb/src/nweb_impl.cc
@@ -1590,6 +1590,20 @@ void NWebImpl::RegisterNativeArkJSFunction(
   }
 }
 
+void NWebImpl::RegisterNativeArkJSFunctionWithResult(
+    const std::string& objName,
+    const std::vector<std::string>& methodName,
+    std::vector<NativeJSProxyCallbackFuncWithResult>&& callback,
+    bool isAsync,
+    const std::string& permission) {
+  if (nweb_delegate_ != nullptr) {
+    nweb_delegate_->RegisterNativeJSProxyWithResult(objName, methodName,
+                                          std::move(callback), isAsync, permission);
+  } else {
+    LOG(ERROR) << "nweb_delegate_ is nullptr";
+  }
+}
+
 void NWebImpl::UnRegisterNativeArkJSFunction(const char* objName) {
   if (nweb_delegate_ != nullptr) {
     nweb_delegate_->UnRegisterNativeArkJSFunction(objName);
diff --git a/ohos_nweb/src/nweb_impl.h b/ohos_nweb/src/nweb_impl.h
index 752920b8db5af207b881675eecf1d5ed6c0f8ab9..e1b337ce04ed002725d1ec90d3a828a07db86d87 100644
--- a/ohos_nweb/src/nweb_impl.h
+++ b/ohos_nweb/src/nweb_impl.h
@@ -120,12 +120,20 @@ class NWebImpl : public NWeb {
       const char* objName,
       const std::vector<std::shared_ptr<NWebJsProxyCallback>> &callbacks) override;
   using NativeJSProxyCallbackFunc = std::function<char*(std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)>;
+  using NativeJSProxyCallbackFuncWithResult = std::function<std::shared_ptr<OHOS::NWeb::NWebValue>(
+      std::vector<std::vector<uint8_t>>&, std::vector<size_t>&)>;
   void RegisterNativeArkJSFunction(
       const std::string& objName,
       const std::vector<std::string>& methodName,
       std::vector<NativeJSProxyCallbackFunc>&& callback,
       bool isAsync,
       const std::string& permission);
+  void RegisterNativeArkJSFunctionWithResult(
+      const std::string& objName,
+      const std::vector<std::string>& methodName,
+      std::vector<NativeJSProxyCallbackFuncWithResult>&& callback,
+      bool isAsync,
+      const std::string& permission);
   void UnRegisterNativeArkJSFunction(const char* objName) override;
   void RegisterNativeValideCallback(const char* webName, const NativeArkWebOnValidCallback callback) override;
   void RegisterNativeDestroyCallback(const char* webName, const NativeArkWebOnDestroyCallback callback) override;