Hi Hannah,

Thank you for your response. As you mentioned, the 'arrayref()' function is not available in IRIS 2023.1, as I suspected.

However, I managed to resolve this issue by developing a custom method to convert a Python dictionary into an ObjectScript dynamic object. I believe it works quite effectively.

I'll share the code here for anyone interested:

/// This class provides methods for working with embedded Python in various scenarios
Class Utility.Python Extends %RegisteredObject
{

/// ConvertPyDictToDynamicObject recursively converts a Python dictionary to an ObjectScript DynamicObject
/// 
/// Input:
/// - PythonDictionary: The Python dictionary to be converted
/// 
/// Output:
/// Returns a DynamicObject with similar structure and content of the parsed Python dictionary
ClassMethod ConvertPyDictToDynamicObject(PythonDictionary) [ Language = python ]
{
    import iris

    # This is a recursive function to parse a Python dictionary and convert it into an ObjectScript %DynamicObject
    # The method takes two parameters: 'data', which represents the current dictionary being parsed, and 'depth', which keeps track of the nesting level of the current data
    def parse_dictionary_to_dynamic_object(data, depth=0):
        # Create a new ObjectScript DynamicObject through iris module
        dynamic_object = iris.cls('%DynamicObject')._New()

        # If data is a dictionary, iterate through its key-value pairs
        if isinstance(data, dict):
            for key, value in data.items():
                # Recursively parse the value and set it in the DynamicObject
                parsed_value = parse_dictionary_to_dynamic_object(value, depth + 1)
                dynamic_object._Set(key, parsed_value)
        # If data is a list, create a %DynamicArray and parse each item of the list recursively
        elif isinstance(data, list):
            dynamic_array = iris.cls('%DynamicArray')._New()
            for item in data:
                parsed_item = parse_dictionary_to_dynamic_object(item, depth)
                dynamic_array._Push(parsed_item)
            return dynamic_array
        # If data is neither a dictionary nor a list, return the data itself
        else:
            return data

        return dynamic_object
    
    # Call the recursive parsing function with the input Python dictionary
    dynamic_object = parse_dictionary_to_dynamic_object(PythonDictionary)

    # Return the parsed DynamicObject
    return dynamic_object
}

}

You can easily test this method with complex dictionaries, like the one in the following example:

ClassMethod StartTestPyDictConverter()
{
    set dynObj = ##class(Python.MessageBuilder).TestPyDictConverter()
    w "dynObj tested",!
}

ClassMethod TestPyDictConverter() [ Language = python ]
{
    import iris

    data = {
        "person": {
            "name": "John Doe",
            "age": 30,
            "address": {
                "street": "123 Main St",
                "city": "Anytown",
                "zipcode": "12345"
            },
            "emails": ["john@example.com", "doe@example.com"],
            "phone_numbers": [
                {
                    "type": "home",
                    "number": "123-456-7890"
                },
                {
                    "type": "work",
                    "number": "987-654-3210"
                }
            ],
            "friends": [
                {
                    "name": "Alice",
                    "age": 28,
                    "address": {
                        "street": "456 Elm St",
                        "city": "Sometown",
                        "zipcode": "54321"
                    },
                    "emails": ["alice@example.com"],
                    "phone_numbers": [
                        {
                            "type": "mobile",
                            "number": "555-555-5555"
                        }
                    ],
                    "pets": [
                        {
                            "name": "Fluffy",
                            "species": "Cat",
                            "age": 5
                        },
                        {
                            "name": "Spot",
                            "species": "Dog",
                            "age": 3
                        }
                    ]
                },
                {
                    "name": "Bob",
                    "age": 35,
                    "address": {
                        "street": "789 Oak St",
                        "city": "Othertown",
                        "zipcode": "67890"
                    },
                    "emails": ["bob@example.com"],
                    "phone_numbers": [
                        {
                            "type": "mobile",
                            "number": "666-666-6666"
                        }
                    ]
                }
            ]
        },
        "company": {
            "name": "Acme Corporation",
            "address": {
                "street": "456 Business Ave",
                "city": "Bigcity",
                "zipcode": "54321"
            },
            "employees": [
                {
                    "name": "Jane Smith",
                    "position": "Manager",
                    "age": 40,
                    "emails": ["jane@example.com"],
                    "phone_numbers": [
                        {
                            "type": "work",
                            "number": "222-222-2222"
                        }
                    ]
                },
                {
                    "name": "Sam Johnson",
                    "position": "Developer",
                    "age": 35,
                    "emails": ["sam@example.com"],
                    "phone_numbers": [
                        {
                            "type": "work",
                            "number": "333-333-3333"
                        }
                    ]
                }
            ]
        }
    }

    dynObj = iris.cls('Utility.Python').ConvertPyDictToDynamicObject(data)

    return dynObj
}

I've tested it even with more complex dictionaries, like FHIR JSON, and it worked fine.

For example, this is a screenshot from my VSC Debugger: 

I know that answering a question and providing your own response may seem unusual, but I won't delete this question as it could be helpful to someone in the future.

The issue was related to the method "jsonFormatter.FormatToStream", which returned "ByRef" a pStream object that, for some reason, Postman and the other client software didn't handle well. 

A solution is to remove the jsonFormatter and to pass directly the OriginalStream to the function:

Set pResponse = ##class(EnsLib.HTTP.GenericMessage).%New(OriginalStream,,tHttpResponse)

If you prefer to keep the JSONFormatter, just declare the pStream as an object of %Stream.FileCharacter class before using the FormatToStream method:

// Format the newJson with the correct indentation
Set jsonFormatter = ##class(%JSON.Formatter).%New()
// Declare a new stream object
Set pStream = ##class(%Stream.FileCharacter).%New()
Set sc = jsonFormatter.FormatToStream(jsonACK, .pStream)

Now everything works fine.