oauth-codex 2.0.2__tar.gz → 2.1.0__tar.gz

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oauth-codex
-Version: 2.0.2
+Version: 2.1.0
 Summary: Codex OAuth-based Python SDK with a single Client and generate-first API
 Author: Codex
 Requires-Python: >=3.11
@@ -64,6 +64,24 @@ text = client.generate(
 print(text)
 ```
 
+Single-parameter Pydantic tool inputs are also supported.
+
+```python
+from pydantic import BaseModel
+
+
+class ToolInput(BaseModel):
+    query: str
+
+
+def tool(input: ToolInput) -> str:
+    return f"Tool received query: {input.query}"
+
+
+text = client.generate("Use the tool", tools=[tool])
+print(text)
+```
+
 If a tool raises an exception, the SDK forwards it to the model as `{\"error\": ...}` and continues the loop.
 
 ## Async

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/README.md

@@ -50,6 +50,24 @@ text = client.generate(
 print(text)
 ```
 
+Single-parameter Pydantic tool inputs are also supported.
+
+```python
+from pydantic import BaseModel
+
+
+class ToolInput(BaseModel):
+    query: str
+
+
+def tool(input: ToolInput) -> str:
+    return f"Tool received query: {input.query}"
+
+
+text = client.generate("Use the tool", tools=[tool])
+print(text)
+```
+
 If a tool raises an exception, the SDK forwards it to the model as `{\"error\": ...}` and continues the loop.
 
 ## Async

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oauth-codex"
-version = "2.0.2"
+version = "2.1.0"
 description = "Codex OAuth-based Python SDK with a single Client and generate-first API"
 readme = "README.md"
 requires-python = ">=3.11"

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/src/oauth_codex/_client.py

@@ -6,7 +6,9 @@ import inspect
 import json
 import mimetypes
 from pathlib import Path
-from typing import Any, AsyncIterator, Callable, Iterator
+from typing import Any, AsyncIterator, Callable, Iterator, get_type_hints
+
+from pydantic import BaseModel
 
 from ._base_client import SyncAPIClient
 from ._engine import OAuthCodexClient as _EngineClient
@@ -23,7 +25,7 @@ from .store import FallbackTokenStore
 from .tooling import callable_to_tool_schema, normalize_tool_output
 
 DEFAULT_MODEL = "gpt-5.3-codex"
-DEFAULT_MAX_TOOL_ROUNDS = 8
+DEFAULT_MAX_TOOL_ROUNDS = 16
 
 
 class OAuthCodexClient(SyncAPIClient):
@@ -105,7 +107,11 @@ class OAuthCodexClient(SyncAPIClient):
         for _ in range(self.max_tool_rounds):
             result = self._engine.generate(
                 model=self._resolve_model(model),
-                messages=messages,
+                messages=self._messages_for_round(
+                    messages=messages,
+                    previous_response_id=previous_response_id,
+                    tool_results=tool_results,
+                ),
                 tools=normalized_tools,
                 tool_results=tool_results,
                 reasoning={"effort": reasoning_effort},
@@ -151,7 +157,11 @@ class OAuthCodexClient(SyncAPIClient):
         for _ in range(self.max_tool_rounds):
             result = await self._engine.agenerate(
                 model=self._resolve_model(model),
-                messages=messages,
+                messages=self._messages_for_round(
+                    messages=messages,
+                    previous_response_id=previous_response_id,
+                    tool_results=tool_results,
+                ),
                 tools=normalized_tools,
                 tool_results=tool_results,
                 reasoning={"effort": reasoning_effort},
@@ -198,7 +208,11 @@ class OAuthCodexClient(SyncAPIClient):
             round_response_id: str | None = previous_response_id
             events = self._engine.generate_stream(
                 model=self._resolve_model(model),
-                messages=messages,
+                messages=self._messages_for_round(
+                    messages=messages,
+                    previous_response_id=previous_response_id,
+                    tool_results=tool_results,
+                ),
                 tools=normalized_tools,
                 tool_results=tool_results,
                 reasoning={"effort": reasoning_effort},
@@ -247,7 +261,11 @@ class OAuthCodexClient(SyncAPIClient):
             round_response_id: str | None = previous_response_id
             events = await self._engine.agenerate_stream(
                 model=self._resolve_model(model),
-                messages=messages,
+                messages=self._messages_for_round(
+                    messages=messages,
+                    previous_response_id=previous_response_id,
+                    tool_results=tool_results,
+                ),
                 tools=normalized_tools,
                 tool_results=tool_results,
                 reasoning={"effort": reasoning_effort},
@@ -276,6 +294,28 @@ class OAuthCodexClient(SyncAPIClient):
     def _resolve_model(self, model: str | None) -> str:
         return model or self.default_model
 
+    def _is_tool_continuation_round(
+        self,
+        *,
+        previous_response_id: str | None,
+        tool_results: list[ToolResult] | None,
+    ) -> bool:
+        return bool(previous_response_id) and bool(tool_results)
+
+    def _messages_for_round(
+        self,
+        *,
+        messages: list[Message],
+        previous_response_id: str | None,
+        tool_results: list[ToolResult] | None,
+    ) -> list[Message]:
+        if self._is_tool_continuation_round(
+            previous_response_id=previous_response_id,
+            tool_results=tool_results,
+        ):
+            return []
+        return messages
+
     def _build_messages(
         self,
         *,
@@ -371,7 +411,8 @@ class OAuthCodexClient(SyncAPIClient):
             else:
                 try:
                     kwargs = self._parse_tool_kwargs(call.arguments_json)
-                    value = tool(**kwargs)
+                    normalized_kwargs = self._normalize_tool_kwargs(tool, kwargs)
+                    value = tool(**normalized_kwargs)
                     if inspect.isawaitable(value):
                         raise TypeError("async tool is not supported in generate(); use agenerate()")
                     output = self._normalize_tool_output(value)
@@ -394,7 +435,8 @@ class OAuthCodexClient(SyncAPIClient):
             else:
                 try:
                     kwargs = self._parse_tool_kwargs(call.arguments_json)
-                    value = tool(**kwargs)
+                    normalized_kwargs = self._normalize_tool_kwargs(tool, kwargs)
+                    value = tool(**normalized_kwargs)
                     if inspect.isawaitable(value):
                         value = await value
                     output = self._normalize_tool_output(value)
@@ -411,6 +453,74 @@ class OAuthCodexClient(SyncAPIClient):
             raise TypeError("tool arguments must be a JSON object")
         return parsed
 
+    def _normalize_tool_kwargs(
+        self,
+        tool: Callable[..., Any],
+        kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        signature = inspect.signature(tool)
+        resolved_hints = self._resolve_tool_type_hints(tool)
+        params = [
+            param
+            for param in signature.parameters.values()
+            if param.kind not in (param.VAR_POSITIONAL, param.VAR_KEYWORD)
+        ]
+        if not params:
+            return kwargs
+
+        if len(params) == 1:
+            param = params[0]
+            model_type = self._resolve_pydantic_model_type(
+                resolved_hints.get(param.name, param.annotation)
+            )
+            if model_type is not None:
+                if param.name in kwargs:
+                    payload = kwargs[param.name]
+                    if isinstance(payload, model_type):
+                        return kwargs
+                    if not isinstance(payload, dict):
+                        raise TypeError(f"tool argument `{param.name}` must be a JSON object")
+                    normalized = dict(kwargs)
+                    normalized[param.name] = model_type.model_validate(payload)
+                    return normalized
+
+                if not kwargs and param.default is not inspect._empty:
+                    return kwargs
+
+                payload = kwargs
+                normalized_payload = (
+                    payload
+                    if isinstance(payload, model_type)
+                    else model_type.model_validate(payload)
+                )
+                return {param.name: normalized_payload}
+
+        normalized = dict(kwargs)
+        for param in params:
+            model_type = self._resolve_pydantic_model_type(
+                resolved_hints.get(param.name, param.annotation)
+            )
+            if model_type is None or param.name not in normalized:
+                continue
+            payload = normalized[param.name]
+            if isinstance(payload, model_type):
+                continue
+            if not isinstance(payload, dict):
+                raise TypeError(f"tool argument `{param.name}` must be a JSON object")
+            normalized[param.name] = model_type.model_validate(payload)
+        return normalized
+
+    def _resolve_pydantic_model_type(self, annotation: Any) -> type[BaseModel] | None:
+        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+            return annotation
+        return None
+
+    def _resolve_tool_type_hints(self, tool: Callable[..., Any]) -> dict[str, Any]:
+        try:
+            return get_type_hints(tool)
+        except Exception:
+            return {}
+
     def _normalize_tool_output(self, output: Any) -> dict[str, Any]:
         return normalize_tool_output(output)
 

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/src/oauth_codex/_engine.py

@@ -199,7 +199,15 @@ class OAuthCodexClient:
     ) -> str | GenerateResult:
         self._require_responses_mode(api_mode)
 
-        normalized_messages = self._normalize_messages(prompt=prompt, messages=messages)
+        allows_empty_messages = self._is_tool_continuation_request(
+            previous_response_id=previous_response_id,
+            tool_results=tool_results,
+        )
+        normalized_messages = self._normalize_messages(
+            prompt=prompt,
+            messages=messages,
+            allow_empty_messages=allows_empty_messages,
+        )
         normalized_tools = normalize_tool_inputs(tools)
         normalized_tool_results = self._normalize_tool_results(tool_results)
 
@@ -276,7 +284,15 @@ class OAuthCodexClient:
     ) -> str | GenerateResult:
         self._require_responses_mode(api_mode)
 
-        normalized_messages = self._normalize_messages(prompt=prompt, messages=messages)
+        allows_empty_messages = self._is_tool_continuation_request(
+            previous_response_id=previous_response_id,
+            tool_results=tool_results,
+        )
+        normalized_messages = self._normalize_messages(
+            prompt=prompt,
+            messages=messages,
+            allow_empty_messages=allows_empty_messages,
+        )
         normalized_tools = normalize_tool_inputs(tools)
         normalized_tool_results = self._normalize_tool_results(tool_results)
 
@@ -353,7 +369,15 @@ class OAuthCodexClient:
     ) -> Iterator[str] | Iterator[StreamEvent]:
         self._require_responses_mode(api_mode)
 
-        normalized_messages = self._normalize_messages(prompt=prompt, messages=messages)
+        allows_empty_messages = self._is_tool_continuation_request(
+            previous_response_id=previous_response_id,
+            tool_results=tool_results,
+        )
+        normalized_messages = self._normalize_messages(
+            prompt=prompt,
+            messages=messages,
+            allow_empty_messages=allows_empty_messages,
+        )
         normalized_tools = normalize_tool_inputs(tools)
         normalized_tool_results = self._normalize_tool_results(tool_results)
 
@@ -426,7 +450,15 @@ class OAuthCodexClient:
     ) -> AsyncIterator[str] | AsyncIterator[StreamEvent]:
         self._require_responses_mode(api_mode)
 
-        normalized_messages = self._normalize_messages(prompt=prompt, messages=messages)
+        allows_empty_messages = self._is_tool_continuation_request(
+            previous_response_id=previous_response_id,
+            tool_results=tool_results,
+        )
+        normalized_messages = self._normalize_messages(
+            prompt=prompt,
+            messages=messages,
+            allow_empty_messages=allows_empty_messages,
+        )
         normalized_tools = normalize_tool_inputs(tools)
         normalized_tool_results = self._normalize_tool_results(tool_results)
 
@@ -1392,6 +1424,7 @@ class OAuthCodexClient:
         *,
         prompt: str | None,
         messages: list[Message] | None,
+        allow_empty_messages: bool = False,
     ) -> list[Message]:
         if (prompt is None and messages is None) or (prompt is not None and messages is not None):
             raise ValueError("Provide exactly one of `prompt` or `messages`")
@@ -1399,10 +1432,20 @@ class OAuthCodexClient:
         if prompt is not None:
             return [{"role": "user", "content": prompt}]
 
-        if not isinstance(messages, list) or not messages:
+        if not isinstance(messages, list):
+            raise ValueError("`messages` must be a non-empty list")
+        if not messages and not allow_empty_messages:
             raise ValueError("`messages` must be a non-empty list")
         return [dict(item) for item in messages]
 
+    def _is_tool_continuation_request(
+        self,
+        *,
+        previous_response_id: str | None,
+        tool_results: list[ToolResult] | None,
+    ) -> bool:
+        return bool(previous_response_id) and bool(tool_results)
+
     def _normalize_tool_results(
         self,
         tool_results: list[ToolResult] | None,

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/src/oauth_codex/_version.py

@@ -1,2 +1,2 @@
 __title__ = "oauth-codex"
-__version__ = "2.0.2"
+__version__ = "2.1.0"

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/src/oauth_codex/tooling.py

@@ -3,11 +3,32 @@ from __future__ import annotations
 import inspect
 import json
 from types import UnionType
-from typing import Any, get_args, get_origin
+from typing import Any, get_args, get_origin, get_type_hints
 
 from .core_types import ToolInput, ToolResult, ToolSchema
 from .errors import SDKRequestError
 
+try:
+    from pydantic import BaseModel
+except Exception:  # pragma: no cover - pydantic is a runtime dependency
+    BaseModel = None  # type: ignore[assignment]
+
+
+def _is_pydantic_model_type(annotation: Any) -> bool:
+    return bool(
+        BaseModel is not None
+        and isinstance(annotation, type)
+        and issubclass(annotation, BaseModel)
+    )
+
+
+def _pydantic_model_to_schema(model_type: type[Any]) -> dict[str, Any]:
+    if hasattr(model_type, "model_json_schema"):
+        schema = model_type.model_json_schema()
+        if isinstance(schema, dict):
+            return schema
+    return {"type": "object"}
+
 
 def _python_type_to_schema(annotation: Any) -> dict[str, Any]:
     if annotation is inspect._empty:
@@ -33,6 +54,8 @@ def _python_type_to_schema(annotation: Any) -> dict[str, Any]:
     args = get_args(annotation)
 
     if origin is None:
+        if _is_pydantic_model_type(annotation):
+            return _pydantic_model_to_schema(annotation)
         if annotation is str:
             return {"type": "string"}
         if annotation is int:
@@ -67,16 +90,39 @@ def _python_type_to_schema(annotation: Any) -> dict[str, Any]:
 
 def callable_to_tool_schema(func: Any) -> ToolSchema:
     signature = inspect.signature(func)
+    try:
+        resolved_hints = get_type_hints(func)
+    except Exception:
+        resolved_hints = {}
+
     doc = inspect.getdoc(func) or ""
     description = doc.splitlines()[0] if doc else f"Tool `{getattr(func, '__name__', 'tool')}`"
 
+    params = [
+        param
+        for param in signature.parameters.values()
+        if param.kind not in (param.VAR_POSITIONAL, param.VAR_KEYWORD)
+    ]
+    if len(params) == 1:
+        single = params[0]
+        single_annotation = resolved_hints.get(single.name, single.annotation)
+        if _is_pydantic_model_type(single_annotation):
+            model_schema = _python_type_to_schema(single_annotation)
+            if model_schema.get("type") == "object":
+                return {
+                    "type": "function",
+                    "name": getattr(func, "__name__", "tool"),
+                    "description": description,
+                    "parameters": model_schema,
+                }
+
     properties: dict[str, Any] = {}
     required: list[str] = []
 
-    for name, param in signature.parameters.items():
-        if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
-            continue
-        properties[name] = _python_type_to_schema(param.annotation)
+    for param in params:
+        name = param.name
+        annotation = resolved_hints.get(name, param.annotation)
+        properties[name] = _python_type_to_schema(annotation)
         if param.default is inspect._empty:
             required.append(name)
 
@@ -93,6 +139,7 @@ def callable_to_tool_schema(func: Any) -> ToolSchema:
     }
 
 
+
 def _normalize_dict_tool(tool: dict[str, Any]) -> ToolSchema:
     if tool.get("type") == "function" and "function" in tool and isinstance(tool["function"], dict):
         fn = tool["function"]

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/src/oauth_codex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oauth-codex
-Version: 2.0.2
+Version: 2.1.0
 Summary: Codex OAuth-based Python SDK with a single Client and generate-first API
 Author: Codex
 Requires-Python: >=3.11
@@ -64,6 +64,24 @@ text = client.generate(
 print(text)
 ```
 
+Single-parameter Pydantic tool inputs are also supported.
+
+```python
+from pydantic import BaseModel
+
+
+class ToolInput(BaseModel):
+    query: str
+
+
+def tool(input: ToolInput) -> str:
+    return f"Tool received query: {input.query}"
+
+
+text = client.generate("Use the tool", tools=[tool])
+print(text)
+```
+
 If a tool raises an exception, the SDK forwards it to the model as `{\"error\": ...}` and continues the loop.
 
 ## Async

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/tests/test_engine_stream_and_continuity.py

@@ -4,7 +4,7 @@ import pytest
 
 from conftest import InMemoryTokenStore
 from oauth_codex._engine import OAuthCodexClient as EngineClient
-from oauth_codex.core_types import OAuthTokens, ToolResult
+from oauth_codex.core_types import GenerateResult, OAuthTokens, ToolResult
 from oauth_codex.errors import SDKRequestError
 from oauth_codex.tooling import tool_results_to_response_items
 
@@ -168,3 +168,47 @@ def test_extract_output_items_for_continuation_sanitizes_response_output() -> No
     assert [item.get("type") for item in items] == ["message", "function_call"]
     assert all("id" not in item for item in items)
     assert all("status" not in item for item in items)
+
+
+def test_generate_allows_empty_messages_for_tool_continuation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    engine = _engine()
+    captured: dict[str, object] = {}
+
+    def fake_generate_responses_sync(**kwargs):
+        captured.update(kwargs)
+        return GenerateResult(text="ok", tool_calls=[], finish_reason="stop")
+
+    monkeypatch.setattr(engine, "_generate_responses_sync", fake_generate_responses_sync)
+
+    out = engine.generate(
+        model="gpt-5.3-codex",
+        messages=[],
+        tool_results=[ToolResult(tool_call_id="call_1", name="tool", output={"ok": True})],
+        previous_response_id="resp_1",
+        return_details=True,
+    )
+
+    assert isinstance(out, GenerateResult)
+    assert captured["messages"] == []
+
+
+def test_generate_rejects_empty_messages_without_tool_continuation() -> None:
+    engine = _engine()
+
+    with pytest.raises(ValueError, match="non-empty"):
+        engine.generate(
+            model="gpt-5.3-codex",
+            messages=[],
+            tool_results=[ToolResult(tool_call_id="call_1", name="tool", output={"ok": True})],
+            previous_response_id=None,
+        )
+
+    with pytest.raises(ValueError, match="non-empty"):
+        engine.generate(
+            model="gpt-5.3-codex",
+            messages=[],
+            tool_results=[],
+            previous_response_id="resp_1",
+        )

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/tests/test_generate_async.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
 import pytest
+from pydantic import BaseModel
 
 from conftest import InMemoryTokenStore
 from oauth_codex import Client
 from oauth_codex.core_types import GenerateResult, OAuthTokens, StreamEvent, ToolCall
 
 
+class ToolInput(BaseModel):
+    query: str
+
+
 def _client() -> Client:
     return Client(
         token_store=InMemoryTokenStore(
@@ -40,6 +45,7 @@ async def test_agenerate_auto_function_calling(monkeypatch: pytest.MonkeyPatch)
 
     assert out == "12"
     assert calls[1]["previous_response_id"] == "resp_1"
+    assert calls[1]["messages"] == []
     tool_results = calls[1]["tool_results"]
     assert tool_results[0].output == {"sum": 12}
 
@@ -80,5 +86,34 @@ async def test_astream_supports_tool_calls(monkeypatch: pytest.MonkeyPatch) -> N
 
     assert out == ["X", "Y"]
     assert calls[1]["previous_response_id"] == "resp_1"
+    assert calls[1]["messages"] == []
     tool_results = calls[1]["tool_results"]
     assert tool_results[0].output == {"product": 12}
+
+
+@pytest.mark.asyncio
+async def test_agenerate_supports_single_pydantic_tool_input(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = _client()
+    calls: list[dict[str, object]] = []
+
+    async def fake_agenerate(**kwargs):
+        calls.append(kwargs)
+        if len(calls) == 1:
+            return GenerateResult(
+                text="",
+                tool_calls=[ToolCall(id="call_1", name="tool", arguments_json='{"query":"hello"}')],
+                finish_reason="tool_calls",
+                response_id="resp_1",
+            )
+        return GenerateResult(text="done", tool_calls=[], finish_reason="stop", response_id="resp_2")
+
+    monkeypatch.setattr(client._engine, "agenerate", fake_agenerate)
+
+    def tool(input: ToolInput) -> str:
+        return f"Tool received query: {input.query}"
+
+    out = await client.agenerate("run", tools=[tool])
+
+    assert out == "done"
+    tool_results = calls[1]["tool_results"]
+    assert tool_results[0].output == {"output": "Tool received query: hello"}

{oauth_codex-2.0.2 → oauth_codex-2.1.0}/tests/test_generate_sync.py

@@ -1,12 +1,21 @@
 from __future__ import annotations
 
 import pytest
+from pydantic import BaseModel, Field
 
 from conftest import InMemoryTokenStore
 from oauth_codex import Client
 from oauth_codex.core_types import GenerateResult, OAuthTokens, StreamEvent, ToolCall
 
 
+class ToolInputWithDescription(BaseModel):
+    query: str = Field(..., description="The query to be processed by the tool.")
+
+
+class ToolInput(BaseModel):
+    query: str
+
+
 def _client() -> Client:
     return Client(
         token_store=InMemoryTokenStore(
@@ -86,12 +95,42 @@ def test_generate_auto_function_calling(monkeypatch: pytest.MonkeyPatch) -> None
 
     assert out == "5"
     assert calls[1]["previous_response_id"] == "resp_1"
+    assert calls[1]["messages"] == []
     tool_results = calls[1]["tool_results"]
     assert len(tool_results) == 1
     assert tool_results[0].name == "add"
     assert tool_results[0].output == {"sum": 5}
 
 
+def test_generate_replays_messages_when_tool_round_has_no_response_id(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    client = _client()
+    calls: list[dict[str, object]] = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        if len(calls) == 1:
+            return GenerateResult(
+                text="",
+                tool_calls=[ToolCall(id="call_1", name="add", arguments_json='{"a":1,"b":2}')],
+                finish_reason="tool_calls",
+                response_id=None,
+            )
+        return GenerateResult(text="3", tool_calls=[], finish_reason="stop", response_id="resp_2")
+
+    monkeypatch.setattr(client._engine, "generate", fake_generate)
+
+    def add(a: int, b: int) -> dict[str, int]:
+        return {"sum": a + b}
+
+    out = client.generate("1+2", tools=[add])
+
+    assert out == "3"
+    assert calls[1]["previous_response_id"] is None
+    assert calls[1]["messages"] == calls[0]["messages"]
+
+
 def test_generate_tool_failure_is_forwarded_to_model(monkeypatch: pytest.MonkeyPatch) -> None:
     client = _client()
     calls: list[dict[str, object]] = []
@@ -147,6 +186,75 @@ def test_generate_wraps_string_tool_output_as_dict(monkeypatch: pytest.MonkeyPat
     assert tool_results[0].output == {"output": "hello"}
 
 
+def test_generate_supports_single_pydantic_tool_input_with_flat_payload(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    client = _client()
+    calls: list[dict[str, object]] = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        if len(calls) == 1:
+            return GenerateResult(
+                text="",
+                tool_calls=[ToolCall(id="call_1", name="tool", arguments_json='{"query":"hello"}')],
+                finish_reason="tool_calls",
+                response_id="resp_1",
+            )
+        return GenerateResult(text="done", tool_calls=[], finish_reason="stop", response_id="resp_2")
+
+    monkeypatch.setattr(client._engine, "generate", fake_generate)
+
+    def tool(input: ToolInputWithDescription) -> str:
+        return f"Tool received query: {input.query}"
+
+    out = client.generate("run", tools=[tool])
+
+    assert out == "done"
+    first_round_tools = calls[0]["tools"]
+    assert isinstance(first_round_tools, list)
+    assert first_round_tools[0]["parameters"]["type"] == "object"
+    assert "query" in first_round_tools[0]["parameters"]["properties"]
+    assert "input" not in first_round_tools[0]["parameters"]["properties"]
+    tool_results = calls[1]["tool_results"]
+    assert tool_results[0].output == {"output": "Tool received query: hello"}
+
+
+def test_generate_supports_single_pydantic_tool_input_with_nested_payload(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    client = _client()
+    calls: list[dict[str, object]] = []
+
+    def fake_generate(**kwargs):
+        calls.append(kwargs)
+        if len(calls) == 1:
+            return GenerateResult(
+                text="",
+                tool_calls=[
+                    ToolCall(
+                        id="call_1",
+                        name="tool",
+                        arguments_json='{"input":{"query":"hello"}}',
+                    )
+                ],
+                finish_reason="tool_calls",
+                response_id="resp_1",
+            )
+        return GenerateResult(text="done", tool_calls=[], finish_reason="stop", response_id="resp_2")
+
+    monkeypatch.setattr(client._engine, "generate", fake_generate)
+
+    def tool(input: ToolInput) -> str:
+        return f"Tool received query: {input.query}"
+
+    out = client.generate("run", tools=[tool])
+
+    assert out == "done"
+    tool_results = calls[1]["tool_results"]
+    assert tool_results[0].output == {"output": "Tool received query: hello"}
+
+
 def test_generate_raises_when_tool_round_limit_exceeded(monkeypatch: pytest.MonkeyPatch) -> None:
     client = _client()
     client.max_tool_rounds = 2
@@ -197,5 +305,6 @@ def test_stream_supports_tool_calls(monkeypatch: pytest.MonkeyPatch) -> None:
 
     assert out == ["A", "B"]
     assert calls[1]["previous_response_id"] == "resp_1"
+    assert calls[1]["messages"] == []
     tool_results = calls[1]["tool_results"]
     assert tool_results[0].output == {"sum": 3}