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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oauth-codex
-Version: 2.0.2
+Version: 2.0.3
 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.0.3}/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.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oauth-codex"
-version = "2.0.2"
+version = "2.0.3"
 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.0.3}/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
@@ -371,7 +373,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 +397,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 +415,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.0.3}/src/oauth_codex/_version.py

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

{oauth_codex-2.0.2 → oauth_codex-2.0.3}/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.0.3}/src/oauth_codex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oauth-codex
-Version: 2.0.2
+Version: 2.0.3
 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.0.3}/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(
@@ -82,3 +87,31 @@ async def test_astream_supports_tool_calls(monkeypatch: pytest.MonkeyPatch) -> N
     assert calls[1]["previous_response_id"] == "resp_1"
     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.0.3}/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(
@@ -147,6 +156,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