Merge branch 'main' into dependabot/uv/langsmith-0.8.0

Author: brianstrauch

.github/workflows/omes.yml

@@ -432,7 +432,7 @@ class IPv4AddressJSONEncoder(AdvancedJSONEncoder):
 class IPv4AddressJSONTypeConverter(JSONTypeConverter):
     def to_typed_value(
         self, hint: Type, value: Any
-    ) -> Union[Optional[Any], _JSONTypeConverterUnhandled]:
+    ) -> Union[Optional[Any], JSONTypeConverterUnhandled]:
         if issubclass(hint, ipaddress.IPv4Address):
             return ipaddress.IPv4Address(value)
         return JSONTypeConverter.Unhandled

README.md

@@ -1,16 +1,24 @@
 """Initialize Temporal OpenAI Agents overrides."""
 
 import dataclasses
+import json
 import typing
 from collections.abc import AsyncIterator, Callable, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from datetime import timedelta
 
+import pydantic
 from agents import ModelProvider, Trace, set_trace_provider
 from agents.run import get_default_agent_runner, set_default_agent_runner
 from agents.tracing import get_trace_provider
 from agents.tracing.provider import DefaultTraceProvider
 
+# construct_type is OpenAI's lenient (non-validating) model builder, the same
+# one the SDK uses to parse live API responses. It is in a private module but
+# has no public alias.
+from openai._models import construct_type
+
+import temporalio.api.common.v1
 from temporalio.contrib.openai_agents._invoke_model_activity import ModelActivity
 from temporalio.contrib.openai_agents._model_parameters import ModelActivityParameters
 from temporalio.contrib.openai_agents._openai_runner import (
@@ -25,12 +33,14 @@
 from temporalio.contrib.openai_agents.workflow import AgentsWorkflowError
 from temporalio.contrib.opentelemetry._tracer_provider import ReplaySafeTracerProvider
 from temporalio.contrib.pydantic import (
-    PydanticPayloadConverter,
+    PydanticJSONPlainPayloadConverter,
     ToJsonOptions,
 )
 from temporalio.converter import (
+    CompositePayloadConverter,
     DataConverter,
     DefaultPayloadConverter,
+    JSONPlainPayloadConverter,
 )
 from temporalio.plugin import SimplePlugin
 from temporalio.worker import WorkflowRunner
@@ -64,12 +74,72 @@ def _set_open_ai_agent_temporal_overrides(
         set_trace_provider(previous_trace_provider or DefaultTraceProvider())
 
 
-class OpenAIPayloadConverter(PydanticPayloadConverter):
+def _lenient_construct(type_: typing.Any, value: typing.Any) -> typing.Any:
+    """Build ``value`` into ``type_`` without enforcing required fields.
+
+    OpenAI's ``construct_type`` handles its own response models (and the
+    unions/lists thereof), but not the ``agents`` dataclasses that wrap them
+    (e.g. ``ModelResponse``), so the dataclass layer is reconstructed here and
+    each field delegated to ``construct_type``. ``include_extras`` preserves the
+    ``Annotated`` discriminators the unions rely on.
+    """
+    if (
+        isinstance(type_, type)
+        and dataclasses.is_dataclass(type_)
+        and isinstance(value, dict)
+    ):
+        hints = typing.get_type_hints(type_, include_extras=True)
+        return type_(
+            **{
+                field.name: _lenient_construct(
+                    hints.get(field.name, object), value[field.name]
+                )
+                for field in dataclasses.fields(type_)
+                if field.name in value
+            }
+        )
+    return construct_type(type_=type_, value=value)
+
+
+class _OpenAIJSONPlainPayloadConverter(PydanticJSONPlainPayloadConverter):
+    """Strict pydantic deserialization with a lenient fallback.
+
+    OpenAI's response models can drift from live API payloads (e.g. a
+    deprecated-but-required field the API has stopped sending). The SDK tolerates
+    this when parsing responses, but strict ``validate_json`` on the workflow
+    side does not, so fall back to lenient construction when validation fails.
+    """
+
+    def from_payload(
+        self,
+        payload: temporalio.api.common.v1.Payload,
+        type_hint: type | None = None,
+    ) -> typing.Any:
+        """See base class."""
+        try:
+            return super().from_payload(payload, type_hint)
+        except pydantic.ValidationError:
+            if type_hint is None:
+                raise
+            return _lenient_construct(type_hint, json.loads(payload.data))
+
+
+class OpenAIPayloadConverter(CompositePayloadConverter):
     """PayloadConverter for OpenAI agents."""
 
     def __init__(self) -> None:
         """Initialize a payload converter."""
-        super().__init__(ToJsonOptions(exclude_unset=True))
+        json_payload_converter = _OpenAIJSONPlainPayloadConverter(
+            ToJsonOptions(exclude_unset=True)
+        )
+        super().__init__(
+            *(
+                c
+                if not isinstance(c, JSONPlainPayloadConverter)
+                else json_payload_converter
+                for c in DefaultPayloadConverter.default_encoding_payload_converters
+            )
+        )
 
 
 def _data_converter(converter: DataConverter | None) -> DataConverter:

temporalio/contrib/openai_agents/_temporal_openai_agents.py

@@ -31,6 +31,7 @@
     JSONPlainPayloadConverter,
     JSONProtoPayloadConverter,
     JSONTypeConverter,
+    JSONTypeConverterUnhandled,
     PayloadConverter,
     value_to_type,
 )
@@ -76,6 +77,7 @@
     "JSONPlainPayloadConverter",
     "JSONProtoPayloadConverter",
     "JSONTypeConverter",
+    "JSONTypeConverterUnhandled",
     "PayloadCodec",
     "PayloadConverter",
     "PayloadLimitsConfig",

temporalio/converter/__init__.py

@@ -548,23 +548,28 @@ def default(self, o: Any) -> Any:
         return super().default(o)
 
 
-_JSONTypeConverterUnhandled = NewType("_JSONTypeConverterUnhandled", object)
+JSONTypeConverterUnhandled = NewType("JSONTypeConverterUnhandled", object)
+"""Type of :py:attr:`JSONTypeConverter.Unhandled`."""
+
+_JSONTypeConverterUnhandled = JSONTypeConverterUnhandled
 
 
 class JSONTypeConverter(ABC):
     """Converter for converting an object from Python :py:func:`json.loads`
     result (e.g. scalar, list, or dict) to a known type.
     """
 
-    Unhandled = _JSONTypeConverterUnhandled(object())
+    Unhandled: ClassVar[JSONTypeConverterUnhandled] = JSONTypeConverterUnhandled(
+        object()
+    )
     """Sentinel value that must be used as the result of
     :py:meth:`to_typed_value` to say the given type is not handled by this
     converter."""
 
     @abstractmethod
     def to_typed_value(
         self, hint: type, value: Any
-    ) -> Any | None | _JSONTypeConverterUnhandled:
+    ) -> Any | None | JSONTypeConverterUnhandled:
         """Convert the given value to a type based on the given hint.
 
         Args:

temporalio/converter/_payload_converter.py

@@ -547,7 +547,9 @@ def research_mock_model():
                         id="",
                         status="completed",
                         type="web_search_call",
-                        action=ActionSearch(query="", type="search"),
+                        action=ActionSearch.model_construct(
+                            type="search", queries=[""]
+                        ),
                     ),
                     ResponseBuilders.response_output_message("Granada"),
                 ],

tests/contrib/openai_agents/test_openai.py

@@ -16,6 +16,8 @@
     Dict,  # type:ignore[reportDeprecated]
     Literal,
     NewType,
+    get_args,
+    get_type_hints,
 )
 from uuid import UUID, uuid4
 
@@ -40,12 +42,12 @@
     DefaultPayloadConverter,
     JSONPlainPayloadConverter,
     JSONTypeConverter,
+    JSONTypeConverterUnhandled,
     PayloadCodec,
     decode_search_attributes,
     encode_search_attribute_values,
     value_to_type,
 )
-from temporalio.converter._payload_converter import _JSONTypeConverterUnhandled
 from temporalio.exceptions import (
     ApplicationError,
     FailureError,
@@ -869,12 +871,22 @@ def default(self, o: Any) -> Any:
 class IPv4AddressJSONTypeConverter(JSONTypeConverter):
     def to_typed_value(
         self, hint: type, value: Any
-    ) -> Any | None | _JSONTypeConverterUnhandled:
+    ) -> Any | None | JSONTypeConverterUnhandled:
         if inspect.isclass(hint) and issubclass(hint, ipaddress.IPv4Address):
             return ipaddress.IPv4Address(value)
         return JSONTypeConverter.Unhandled
 
 
+def test_json_type_converter_unhandled_type_public():
+    return_type = get_type_hints(JSONTypeConverter.to_typed_value)["return"]
+
+    assert JSONTypeConverterUnhandled.__name__ == "JSONTypeConverterUnhandled"
+    assert JSONTypeConverterUnhandled in get_args(return_type)
+    assert JSONTypeConverterUnhandled(JSONTypeConverter.Unhandled) is (
+        JSONTypeConverter.Unhandled
+    )
+
+
 async def test_json_type_converter():
     addr = ipaddress.IPv4Address("1.2.3.4")
     custom_conv = dataclasses.replace(