vellum-ai 0.14.8__py3-none-any.whl → 0.14.10__py3-none-any.whl

vellum/workflows/expressions/tests/test_expressions.py

@@ -0,0 +1,310 @@
+import pytest
+
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.state.base import BaseState
+
+
+class Comparable:
+    """A custom class with two values, where comparisons use a computed metric (multiplication)."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1  # First numerical value
+        self.value2 = value2  # Second numerical value
+
+    def computed_value(self):
+        return self.value1 * self.value2  # Multiply for comparison
+
+    def __ge__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() >= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() >= other
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() > other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() > other
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() <= other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() <= other
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, Comparable):
+            return self.computed_value() < other.computed_value()
+        elif isinstance(other, (int, float)):
+            return self.computed_value() < other
+        return NotImplemented
+
+
+class NonComparable:
+    """A custom class that does not support comparisons."""
+
+    def __init__(self, value1, value2):
+        self.value1 = value1
+        self.value2 = value2
+
+
+class TestState(BaseState):
+    pass
+
+
+def test_greater_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 >= 20
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 >= 18
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanOrEqualToExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 >= 19
+    assert GreaterThanOrEqualToExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_greater_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 > 20
+    assert GreaterThanExpression(lhs=obj1, rhs=obj3).resolve(state) is True  # 20 > 18
+    assert GreaterThanExpression(lhs=obj3, rhs=obj4).resolve(state) is False  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert GreaterThanExpression(lhs=obj1, rhs=19).resolve(state) is True  # 20 > 19
+    assert GreaterThanExpression(lhs=obj3, rhs=20).resolve(state) is False  # 18 < 20
+
+
+def test_greater_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_greater_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        GreaterThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'>' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than_or_equal_to():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state) is True  # 20 <= 20
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 > 18
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 <= 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanOrEqualToExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 <= 21
+    assert LessThanOrEqualToExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_or_equal_to_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_or_equal_to_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanOrEqualToExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<=' not supported between instances of 'NonComparable' and 'Comparable'"
+
+
+def test_less_than():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)  # Computed: 4 × 5 = 20
+    obj2 = Comparable(2, 10)  # Computed: 2 × 10 = 20
+    obj3 = Comparable(3, 6)  # Computed: 3 × 6 = 18
+    obj4 = Comparable(5, 5)  # Computed: 5 × 5 = 25
+
+    state = TestState()
+
+    # WHEN comparing objects
+    assert LessThanExpression(lhs=obj1, rhs=obj2).resolve(state) is False  # 20 < 20
+    assert LessThanExpression(lhs=obj1, rhs=obj3).resolve(state) is False  # 20 < 18
+    assert LessThanExpression(lhs=obj3, rhs=obj4).resolve(state) is True  # 18 < 25
+
+    # WHEN comparing to raw numbers
+    assert LessThanExpression(lhs=obj1, rhs=21).resolve(state) is True  # 20 < 21
+    assert LessThanExpression(lhs=obj3, rhs=17).resolve(state) is False  # 18 > 17
+
+
+def test_less_than_invalid():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = "invalid"
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'str'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'str' and 'Comparable'"
+
+
+def test_less_than_non_comparable():
+    # GIVEN objects with two values
+    obj1 = Comparable(4, 5)
+    obj2 = NonComparable(2, 10)
+
+    state = TestState()
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj1, rhs=obj2).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'Comparable' and 'NonComparable'"
+
+    # WHEN comparing objects with incompatible types
+    with pytest.raises(TypeError) as exc_info:
+        LessThanExpression(lhs=obj2, rhs=obj1).resolve(state)
+
+    # THEN the expected error is raised
+    assert str(exc_info.value) == "'<' not supported between instances of 'NonComparable' and 'Comparable'"

vellum/workflows/expressions/tests/test_parse_json.py

@@ -0,0 +1,31 @@
+import pytest
+
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+def test_parse_json_invalid_json():
+    # GIVEN an invalid JSON string
+    state = BaseState()
+    expression = ConstantValueReference('{"key": value}').parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Failed to parse JSON" in str(exc_info.value)
+
+
+def test_parse_json_invalid_type():
+    # GIVEN a non-string value
+    state = BaseState()
+    expression = ConstantValueReference(123).parse_json()
+
+    # WHEN we attempt to resolve the expression
+    with pytest.raises(InvalidExpressionException) as exc_info:
+        expression.resolve(state)
+
+    # THEN an exception should be raised
+    assert "Expected a string, but got 123 of type <class 'int'>" == str(exc_info.value)

vellum/workflows/nodes/bases/base.py

@@ -318,9 +318,12 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
             original_base = get_original_base(self.__class__)
 
             args = get_args(original_base)
-            state_type = args[0]
 
-            if isinstance(state_type, TypeVar):
+            if args and len(args) > 0:
+                state_type = args[0]
+                if isinstance(state_type, TypeVar):
+                    state_type = BaseState
+            else:
                 state_type = BaseState
 
             self.state = state_type()

vellum/workflows/nodes/core/templating_node/node.py

@@ -82,7 +82,6 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     def run(self) -> Outputs:
         rendered_template = self._render_template()
         result = self._cast_rendered_template(rendered_template)
-
         return self.Outputs(result=result)
 
     def _render_template(self) -> str:

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -234,3 +234,52 @@ def test_templating_node__last_chat_message():
 
     # THEN the output is the expected JSON
     assert outputs.result == [ChatMessage(role="USER", text="Hello")]
+
+
+def test_templating_node__function_call_value_input():
+    # GIVEN a templating node that receives a FunctionCallVellumValue
+    class FunctionCallTemplateNode(TemplatingNode[BaseState, FunctionCall]):
+        template = """{{ function_call }}"""
+        inputs = {
+            "function_call": FunctionCallVellumValue(
+                type="FUNCTION_CALL",
+                value=FunctionCall(name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"),
+            )
+        }
+
+    # WHEN the node is run
+    node = FunctionCallTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected function call
+    assert outputs.result == FunctionCall(
+        name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"
+    )
+
+
+def test_templating_node__function_call_as_json():
+    # GIVEN a node that receives a FunctionCallVellumValue but outputs as Json
+    class JsonOutputNode(TemplatingNode[BaseState, Json]):
+        template = """{{ function_call }}"""
+        inputs = {
+            "function_call": FunctionCallVellumValue(
+                type="FUNCTION_CALL",
+                value=FunctionCall(name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"),
+            )
+        }
+
+    # WHEN the node is run
+    node = JsonOutputNode()
+    outputs = node.run()
+
+    # THEN we get just the FunctionCall data as JSON
+    assert outputs.result == {
+        "name": "test_function",
+        "arguments": {"key": "value"},
+        "id": "test_id",
+        "state": "FULFILLED",
+    }
+
+    # AND we can access fields directly
+    assert outputs.result["arguments"] == {"key": "value"}
+    assert outputs.result["name"] == "test_function"

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -5,7 +5,6 @@ from vellum.client.core.api_error import ApiError
 from vellum.workflows.constants import APIRequestMethod, AuthorizationType
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes import APINode
-from vellum.workflows.state import BaseState
 from vellum.workflows.types.core import VellumSecret
 
 
@@ -29,7 +28,7 @@ def test_run_workflow__secrets(vellum_client):
         }
         bearer_token_value = VellumSecret(name="secret")
 
-    node = SimpleBaseAPINode(state=BaseState())
+    node = SimpleBaseAPINode()
     terminal = node.run()
 
     assert vellum_client.execute_api.call_count == 1
@@ -39,7 +38,7 @@ def test_run_workflow__secrets(vellum_client):
 
 
 def test_api_node_raises_error_when_api_call_fails(vellum_client):
-    # Mock the vellum_client to raise an ApiError
+    # GIVEN an API call that fails
     vellum_client.execute_api.side_effect = ApiError(status_code=400, body="API Error")
 
     class SimpleAPINode(APINode):
@@ -54,14 +53,14 @@ def test_api_node_raises_error_when_api_call_fails(vellum_client):
         }
         bearer_token_value = VellumSecret(name="api_key")
 
-    node = SimpleAPINode(state=BaseState())
+    node = SimpleAPINode()
 
-    # Assert that the NodeException is raised
+    # WHEN we run the node
     with pytest.raises(NodeException) as excinfo:
         node.run()
 
-    # Verify that the exception contains some error message
+    # THEN an exception should be raised
     assert "Failed to prepare HTTP request" in str(excinfo.value)
 
-    # Verify the vellum_client was called
+    # AND the API call should have been made
     assert vellum_client.execute_api.call_count == 1

vellum/workflows/nodes/displayable/code_execution_node/node.py

@@ -19,6 +19,7 @@ from vellum import (
     VellumError,
     VellumValue,
 )
+from vellum.client.core.api_error import ApiError
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.core import RequestOptions
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -103,14 +104,23 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
             input_values = self._compile_code_inputs()
             expected_output_type = primitive_type_to_vellum_variable_type(output_type)
 
-            code_execution_result = self._context.vellum_client.execute_code(
-                input_values=input_values,
-                code=code,
-                runtime=self.runtime,
-                output_type=expected_output_type,
-                packages=self.packages or [],
-                request_options=self.request_options,
-            )
+            try:
+                code_execution_result = self._context.vellum_client.execute_code(
+                    input_values=input_values,
+                    code=code,
+                    runtime=self.runtime,
+                    output_type=expected_output_type,
+                    packages=self.packages or [],
+                    request_options=self.request_options,
+                )
+            except ApiError as e:
+                if e.status_code == 400 and isinstance(e.body, dict) and "message" in e.body:
+                    raise NodeException(
+                        message=e.body["message"],
+                        code=WorkflowErrorCode.INVALID_INPUTS,
+                    )
+
+                raise
 
             if code_execution_result.output.type != expected_output_type:
                 actual_type = code_execution_result.output.type

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -5,6 +5,7 @@ from typing import Any, List, Union
 from pydantic import BaseModel
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.errors.bad_request_error import BadRequestError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
@@ -17,6 +18,7 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState, StateMeta
+from vellum.workflows.types.core import Json
 
 
 def test_run_node__happy_path(vellum_client):
@@ -690,3 +692,54 @@ def main():
         "result": [ChatMessage(role="USER", content=StringChatMessageContent(value="Hello, world!"))],
         "log": "",
     }
+
+
+def test_run_node__execute_code_api_fails__node_exception(vellum_client):
+    # GIVEN a node that will throw a JSON.parse error
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Json]):
+        code = """\
+async function main(inputs: {
+  data: string,
+}): Promise<string> {
+  return JSON.parse(inputs.data)
+}
+"""
+        code_inputs = {
+            "data": "not a valid json string",
+        }
+        runtime = "TYPESCRIPT_5_3_3"
+
+    # AND the execute_code API will fail
+    message = """\
+Code execution error (exit code 1): undefined:1
+not a valid json string
+ ^
+
+SyntaxError: Unexpected token 'o', \"not a valid\"... is not valid JSON
+    at JSON.parse (<anonymous>)
+    at Object.eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:40:40)
+    at step (eval at execute (/workdir/runner.js:16:18), <anonymous>:32:23)
+    at Object.eval [as next] (eval at execute (/workdir/runner.js:16:18), <anonymous>:13:53)
+    at eval (eval at execute (/workdir/runner.js:16:18), <anonymous>:7:71)
+    at new Promise (<anonymous>)
+    at __awaiter (eval at execute (/workdir/runner.js:16:18), <anonymous>:3:12)
+    at Object.main (eval at execute (/workdir/runner.js:16:18), <anonymous>:38:12)
+    at execute (/workdir/runner.js:17:33)
+    at Interface.<anonymous> (/workdir/runner.js:58:5)
+
+Node.js v21.7.3
+"""
+    vellum_client.execute_code.side_effect = BadRequestError(
+        body={
+            "message": message,
+            "log": "",
+        }
+    )
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # AND the error should contain the execution error details
+    assert exc_info.value.message == message

vellum/workflows/nodes/utils.py

@@ -109,7 +109,11 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
 
     if output_type is Json:
         try:
-            return json.loads(result_as_str)
+            data = json.loads(result_as_str)
+            # If we got a FunctionCallVellumValue, return just the value
+            if isinstance(data, dict) and data.get("type") == "FUNCTION_CALL" and "value" in data:
+                return data["value"]
+            return data
         except json.JSONDecodeError:
             raise ValueError("Invalid JSON format for result_as_str")
 
@@ -124,9 +128,16 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
     if issubclass(output_type, BaseModel):
         try:
             data = json.loads(result_as_str)
+            # If we got a FunctionCallVellumValue extract FunctionCall,
+            if (
+                hasattr(output_type, "__name__")
+                and output_type.__name__ == "FunctionCall"
+                and isinstance(data, dict)
+                and "value" in data
+            ):
+                data = data["value"]
+            return output_type.model_validate(data)
         except json.JSONDecodeError:
             raise ValueError("Invalid JSON format for result_as_str")
 
-        return output_type.model_validate(data)
-
     raise ValueError(f"Unsupported output type: {output_type}")