[BugFix] openbb-core: Fix Package Builder In no_validate Path & Handle Lazy Annotations (#7423)

* fix unresolved string annotations in no_validate path

* add regression test

* bump and regenerate locks

---------

Co-authored-by: deeleeramone <>

Author: deeleeramone

openbb_platform/core/openbb/assets/reference.json

@@ -1,9 +1,9 @@
 {
-    "openbb": "1.6.4core",
+    "openbb": "1.6.5core",
     "info": {
         "title": "OpenBB Platform (Python)",
         "description": "Investment research for everyone, anywhere.",
-        "core": "1.6.4",
+        "core": "1.6.5",
         "extensions": {
             "openbb_core_extension": [],
             "openbb_provider_extension": [],

openbb_platform/core/openbb_core/app/static/package_builder.py

@@ -557,8 +557,9 @@ def build(cls, path: str) -> str:
         code += "\nfrom fastapi import Depends"
 
         module_list = [
-            hint_type.__module__ if hasattr(hint_type, "__module__") else hint_type
+            hint_type.__module__
             for hint_type in hint_type_list
+            if hasattr(hint_type, "__module__")
         ]
         module_list = list(set(module_list))
         module_list.sort()  # type: ignore
@@ -1531,6 +1532,11 @@ def get_type_repr(type_hint: Any) -> str:
             if isinstance(type_hint, type):
                 return type_hint.__name__
 
+            # Unwrap ForwardRef to its inner string so we don't emit
+            # ForwardRef('int') in generated signatures.
+            if hasattr(type_hint, "__forward_arg__"):
+                return type_hint.__forward_arg__
+
             s = str(type_hint)
             if s.startswith("typing."):
                 s = s[7:]
@@ -1615,7 +1621,7 @@ def build_func_returns(return_type: type) -> str:
         if return_type == _empty:
             func_returns = "Any"
         elif isinstance(return_type, str):
-            func_returns = f"ForwardRef('{return_type}')"
+            func_returns = return_type
         elif isclass(return_type) and issubclass(return_type, OBBject):
             func_returns = "OBBject"
         else:
@@ -2042,6 +2048,10 @@ def get_field_type(
         try:
             _type = field_type
 
+            # Unwrap ForwardRef to its inner string
+            if hasattr(_type, "__forward_arg__"):
+                _type = _type.__forward_arg__
+
             if "BeforeValidator" in str(_type):
                 _type = "Optional[int]" if is_optional else "int"  # type: ignore
 

openbb_platform/core/poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openbb-core"
-version = "1.6.4"
+version = "1.6.5"
 description = "OpenBB package with core functionality."
 authors = ["OpenBB Team <hello@openbb.co>"]
 license = "AGPL-3.0-only"

openbb_platform/core/pyproject.toml

@@ -896,3 +896,95 @@ def optional_return_dependency(optional: str = "value") -> MockDep | None:
     assert not method_definition._is_safe_dependency(optional_request_dependency)
     assert not method_definition._is_safe_dependency(none_return_dependency)
     assert method_definition._is_safe_dependency(optional_return_dependency)
+
+
+def test_build_func_params_unwraps_forward_ref(method_definition):
+    """Test that ForwardRef annotations are unwrapped in generated function params.
+
+    Regression test: when extensions use `from __future__ import annotations`
+    with `no_validate=True`, annotations remain as strings at runtime.
+    Annotated["int", ...] auto-wraps "int" into ForwardRef("int").
+    The builder must unwrap these to plain type strings.
+    """
+    # pylint: disable=import-outside-toplevel
+    from collections import OrderedDict
+    from typing import ForwardRef
+
+    from openbb_core.app.model.field import OpenBBField
+
+    param_map = OrderedDict(
+        {
+            "symbol": Parameter(
+                name="symbol",
+                kind=Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=Annotated[
+                    ForwardRef("str"), OpenBBField(description="")
+                ],
+            ),
+            "days": Parameter(
+                name="days",
+                kind=Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=Annotated[
+                    ForwardRef("int"), OpenBBField(description="")
+                ],
+                default=7,
+            ),
+            "asset_type": Parameter(
+                name="asset_type",
+                kind=Parameter.POSITIONAL_OR_KEYWORD,
+                annotation=Annotated[
+                    ForwardRef("Literal['stock', 'etf', 'all'] | None"),
+                    OpenBBField(description=""),
+                ],
+                default=None,
+            ),
+        }
+    )
+
+    output = method_definition.build_func_params(param_map)
+
+    assert "ForwardRef" not in output, (
+        f"ForwardRef should be unwrapped in generated params, got:\n{output}"
+    )
+    assert "str," in output
+    assert "int," in output
+    assert "Literal['stock', 'etf', 'all']" in output
+
+
+def test_build_func_returns_string_annotation(method_definition):
+    """Test that string return types are emitted directly, not wrapped in ForwardRef.
+
+    Regression test: `from __future__ import annotations` causes return annotations
+    to be strings. The builder should emit the string directly (e.g., "OBBject")
+    rather than wrapping it as ForwardRef('OBBject').
+    """
+    output = method_definition.build_func_returns(return_type="OBBject")
+    assert output == "OBBject"
+    assert "ForwardRef" not in output
+
+    output2 = method_definition.build_func_returns(return_type="Any")
+    assert output2 == "Any"
+    assert "ForwardRef" not in output2
+
+
+def test_get_field_type_unwraps_forward_ref(docstring_generator):
+    """Test that ForwardRef is unwrapped in docstring type formatting.
+
+    Regression test: ForwardRef('int') should render as 'int' in docstrings,
+    not as the literal string "ForwardRef('int')".
+    """
+    # pylint: disable=import-outside-toplevel
+    from typing import ForwardRef
+
+    result = docstring_generator.get_field_type(ForwardRef("int"), is_required=True)
+    assert "ForwardRef" not in result, (
+        f"ForwardRef should be unwrapped in docstring types, got: {result}"
+    )
+    assert "int" in result
+
+    result2 = docstring_generator.get_field_type(
+        ForwardRef("Literal['stock', 'etf', 'all'] | None"), is_required=False
+    )
+    assert "ForwardRef" not in result2, (
+        f"ForwardRef should be unwrapped in docstring types, got: {result2}"
+    )