From 450507be8391d36cb3a3c98af1bf25f412884c01 Mon Sep 17 00:00:00 2001 From: C1-BA-B1-F3 Date: Fri, 26 Jun 2026 07:56:46 +0800 Subject: [PATCH 1/2] fix: handle bare dict/list annotations in construct_type and transform Guard against empty type args when using bare dict or list annotations (no type parameters, e.g. instead of ). Previously: - construct_type() raised ValueError on bare dict - construct_type() raised IndexError on bare list - _transform_recursive() raised IndexError on bare dict Now these cases gracefully return the data as-is, matching the behavior of parameterized types when the data already matches. Fixes #3338, #3341 --- src/openai/_models.py | 13 +++++++++---- src/openai/_utils/_transform.py | 26 ++++++++++++++++++++++---- tests/test_models.py | 22 ++++++++++++++++++++++ tests/test_transform.py | 22 ++++++++++++++++++++++ 4 files changed, 75 insertions(+), 8 deletions(-) diff --git a/src/openai/_models.py b/src/openai/_models.py index ed4c1f82d6..e2877caad5 100644 --- a/src/openai/_models.py +++ b/src/openai/_models.py @@ -657,8 +657,11 @@ def construct_type(*, value: object, type_: object, metadata: Optional[List[Any] if not is_mapping(value): return value - _, items_type = get_args(type_) # Dict[_, items_type] - return {key: construct_type(value=item, type_=items_type) for key, item in value.items()} + dict_args = get_args(type_) + if len(dict_args) >= 2: + items_type = dict_args[1] + return {key: construct_type(value=item, type_=items_type) for key, item in value.items()} + return dict(value) if ( not is_literal_type(type_) @@ -678,8 +681,10 @@ def construct_type(*, value: object, type_: object, metadata: Optional[List[Any] if not is_list(value): return value - inner_type = args[0] # List[inner_type] - return [construct_type(value=entry, type_=inner_type) for entry in value] + if args: + inner_type = args[0] # List[inner_type] + return [construct_type(value=entry, type_=inner_type) for entry in value] + return list(value) if origin == float: if isinstance(value, int): diff --git a/src/openai/_utils/_transform.py b/src/openai/_utils/_transform.py index 414f38c340..76079b5aa5 100644 --- a/src/openai/_utils/_transform.py +++ b/src/openai/_utils/_transform.py @@ -180,8 +180,11 @@ def _transform_recursive( return _transform_typeddict(data, stripped_type) if origin == dict and is_mapping(data): - items_type = get_args(stripped_type)[1] - return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + args = get_args(stripped_type) + if len(args) >= 2: + items_type = args[1] + return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + return dict(data) if ( # List[T] @@ -196,6 +199,12 @@ def _transform_recursive( if isinstance(data, dict): return cast(object, data) + # bare list/iterable/sequence with no type args - return as-is + if not get_args(stripped_type): + if is_list(data): + return data + return list(data) + inner_type = extract_type_arg(stripped_type, 0) if _no_transform_needed(inner_type): # for some types there is no need to transform anything, so we can get a small @@ -346,8 +355,11 @@ async def _async_transform_recursive( return await _async_transform_typeddict(data, stripped_type) if origin == dict and is_mapping(data): - items_type = get_args(stripped_type)[1] - return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + args = get_args(stripped_type) + if len(args) >= 2: + items_type = args[1] + return {key: _transform_recursive(value, annotation=items_type) for key, value in data.items()} + return dict(data) if ( # List[T] @@ -362,6 +374,12 @@ async def _async_transform_recursive( if isinstance(data, dict): return cast(object, data) + # bare list/iterable/sequence with no type args - return as-is + if not get_args(stripped_type): + if is_list(data): + return data + return list(data) + inner_type = extract_type_arg(stripped_type, 0) if _no_transform_needed(inner_type): # for some types there is no need to transform anything, so we can get a small diff --git a/tests/test_models.py b/tests/test_models.py index cc204bac1d..6e2770be11 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1015,3 +1015,25 @@ class Model(BaseModel): # falls back to list of chars rather than calling str(["h", "e", "l", "l", "o"]) assert m.data["items"] == ["h", "e", "l", "l", "o"] assert m.model_dump()["data"]["items"] == ["h", "e", "l", "l", "o"] + + +def test_bare_dict_annotation() -> None: + result = construct_type(value={"key": "value"}, type_=dict) + assert result == {"key": "value"} + + result = construct_type(value={"a": 1, "b": 2}, type_=dict) + assert result == {"a": 1, "b": 2} + + result = construct_type(value="not a dict", type_=dict) + assert result == "not a dict" + + +def test_bare_list_annotation() -> None: + result = construct_type(value=[1, 2, 3], type_=list) + assert result == [1, 2, 3] + + result = construct_type(value=["a", "b"], type_=list) + assert result == ["a", "b"] + + result = construct_type(value="not a list", type_=list) + assert result == "not a list" diff --git a/tests/test_transform.py b/tests/test_transform.py index bece75dfc7..e4024aa3a5 100644 --- a/tests/test_transform.py +++ b/tests/test_transform.py @@ -458,3 +458,25 @@ async def test_strips_notgiven(use_async: bool) -> None: async def test_strips_omit(use_async: bool) -> None: assert await transform({"foo_bar": "bar"}, Foo1, use_async) == {"fooBar": "bar"} assert await transform({"foo_bar": omit}, Foo1, use_async) == {} + + +class BareDictParams(TypedDict, total=False): + metadata: dict + + +@parametrize +@pytest.mark.asyncio +async def test_bare_dict_in_typeddict(use_async: bool) -> None: + result = await transform({"metadata": {"key": "value"}}, BareDictParams, use_async) + assert result == {"metadata": {"key": "value"}} + + +class BareListParams(TypedDict, total=False): + items: list + + +@parametrize +@pytest.mark.asyncio +async def test_bare_list_in_typeddict(use_async: bool) -> None: + result = await transform({"items": [1, 2, 3]}, BareListParams, use_async) + assert result == {"items": [1, 2, 3]} From 54fafb34948e13696dc32ba3861e16adc490905e Mon Sep 17 00:00:00 2001 From: C1-BA-B1-F3 Date: Fri, 26 Jun 2026 08:34:22 +0800 Subject: [PATCH 2/2] fix: make ResponseFunctionWebSearch.action optional to handle null API responses Fixes #3179 The API can return null for the action field in web search calls (e.g., when the search is still in progress or the action hasn't been determined yet). This change makes the action field Optional[Action] with a default of None, matching the actual API behavior. This allows users to safely check action.type without getting an AttributeError when action is None. --- .../responses/response_function_web_search.py | 2 +- tests/test_response_function_web_search.py | 133 ++++++++++++++++++ 2 files changed, 134 insertions(+), 1 deletion(-) create mode 100644 tests/test_response_function_web_search.py diff --git a/src/openai/types/responses/response_function_web_search.py b/src/openai/types/responses/response_function_web_search.py index 3584992b7d..51c0a1b50c 100644 --- a/src/openai/types/responses/response_function_web_search.py +++ b/src/openai/types/responses/response_function_web_search.py @@ -78,7 +78,7 @@ class ResponseFunctionWebSearch(BaseModel): id: str """The unique ID of the web search tool call.""" - action: Action + action: Optional[Action] = None """ An object describing the specific action taken in this web search call. Includes details on how the model used the web (search, open_page, find_in_page). diff --git a/tests/test_response_function_web_search.py b/tests/test_response_function_web_search.py new file mode 100644 index 0000000000..2dbbb998ce --- /dev/null +++ b/tests/test_response_function_web_search.py @@ -0,0 +1,133 @@ +# Tests for ResponseFunctionWebSearch type +# Verifies that the action field correctly handles None values from the API +import pytest + +from openai.types.responses.response_function_web_search import ( + ActionSearch, + ActionOpenPage, + ActionFind, + ResponseFunctionWebSearch, +) + + +def test_response_function_web_search_with_search_action(): + """Test that a web search call with a search action works correctly.""" + data = { + "id": "ws_123", + "action": { + "type": "search", + "query": "test query", + "queries": ["test query"], + }, + "status": "completed", + "type": "web_search_call", + } + result = ResponseFunctionWebSearch(**data) + assert result.id == "ws_123" + assert result.action is not None + assert isinstance(result.action, ActionSearch) + assert result.action.type == "search" + assert result.action.query == "test query" + + +def test_response_function_web_search_with_open_page_action(): + """Test that a web search call with an open_page action works correctly.""" + data = { + "id": "ws_456", + "action": { + "type": "open_page", + "url": "https://example.com", + }, + "status": "completed", + "type": "web_search_call", + } + result = ResponseFunctionWebSearch(**data) + assert result.id == "ws_456" + assert result.action is not None + assert isinstance(result.action, ActionOpenPage) + assert result.action.type == "open_page" + assert result.action.url == "https://example.com" + + +def test_response_function_web_search_with_find_action(): + """Test that a web search call with a find_in_page action works correctly.""" + data = { + "id": "ws_789", + "action": { + "type": "find_in_page", + "pattern": "search term", + "url": "https://example.com", + }, + "status": "completed", + "type": "web_search_call", + } + result = ResponseFunctionWebSearch(**data) + assert result.id == "ws_789" + assert result.action is not None + assert isinstance(result.action, ActionFind) + assert result.action.type == "find_in_page" + assert result.action.pattern == "search term" + + +def test_response_function_web_search_with_none_action(): + """Test that a web search call with action=None works correctly. + + This is a regression test for GitHub issue #3179. + The API can return null for the action field in some cases + (e.g., when the search is still in progress or the action + hasn't been determined yet). + """ + data = { + "id": "ws_abc", + "action": None, + "status": "completed", + "type": "web_search_call", + } + result = ResponseFunctionWebSearch(**data) + assert result.id == "ws_abc" + assert result.action is None + assert result.status == "completed" + + +def test_response_function_web_search_without_action(): + """Test that a web search call without action field defaults to None.""" + data = { + "id": "ws_def", + "status": "in_progress", + "type": "web_search_call", + } + result = ResponseFunctionWebSearch(**data) + assert result.id == "ws_def" + assert result.action is None + assert result.status == "in_progress" + + +def test_response_function_web_search_action_none_safe_access(): + """Test that users can safely check action type with None action. + + This demonstrates the fix for issue #3179 - users can now safely + access action.type without AttributeError when action is None. + """ + data_with_action = { + "id": "ws_1", + "action": {"type": "search", "query": "test"}, + "status": "completed", + "type": "web_search_call", + } + data_without_action = { + "id": "ws_2", + "action": None, + "status": "completed", + "type": "web_search_call", + } + + result_with = ResponseFunctionWebSearch(**data_with_action) + result_without = ResponseFunctionWebSearch(**data_without_action) + + # This pattern should work without errors + search_count = 0 + for result in [result_with, result_without]: + if result.action is not None and result.action.type == "search": + search_count += 1 + + assert search_count == 1