fix: make AsyncOgxClient functional by inheriting from sync ApiClient

The AsyncOgxClient was completely broken because AsyncApiClient was a
standalone class missing 15+ methods (select_header_accept,
param_serialize, call_api, response_deserialize, etc.) that the
generated API classes depend on. Any call through AsyncOgxClient would
immediately crash with AttributeError. Additionally, all API methods
were synchronous — they could not be awaited.

Root causes:
- AsyncApiClient reimplemented only HTTP transport but omitted all
serialization, deserialization, and parameter handling methods
- Generated API classes (e.g. InspectApi) were shared between sync
and async clients but only had sync method signatures
- Nested API wiring (e.g. client.chat.completions) was only applied
to OgxClient, not AsyncOgxClient

Fix AsyncApiClient by making it inherit from ApiClient, overriding
only __init__ (creates httpx.AsyncClient), call_api (async HTTP
transport), close (async cleanup), and context managers. All
serialization and deserialization methods are inherited unchanged.

Generate proper async API subclasses (e.g. AsyncInspectApi) in the
same file as their sync counterparts via the api.mustache template.
These inherit the _serialize methods and override the three operation
method variants to use async def with await on call_api and aread.

Update AsyncOgxClient to wire Async*Api classes instead of sync ones,
and fix patch_hierarchy.py to apply nested API wiring to both
OgxClient and AsyncOgxClient.

Add RESTResponse.aread() for async response body reading, and update
all export templates to include the new Async*Api classes.

Author: aegeiger

client-sdks/openapi/patch_hierarchy.py

@@ -152,11 +152,13 @@ def patch_optional_import(api_file: Path) -> bool:
 
 
 def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
-    """Patch OgxClient to wire up parent-child API relationships.
+    """Patch OgxClient and AsyncOgxClient to wire up parent-child API relationships.
 
-    Looks for the '# Nested API structure' comment and inserts assignments like:
+    Looks for all '# Nested API structure' comment anchors and inserts assignments like:
         self.chat.completions = self.completions
 
+    This handles both OgxClient and AsyncOgxClient in the same file.
+
     Returns True if the file was modified.
     """
     if not client_file.exists():
@@ -166,14 +168,13 @@ def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
     with open(client_file) as f:
         lines = f.readlines()
 
-    # Find the anchor comment
-    comment_idx = None
+    # Find all anchor comment indices
+    comment_indices = []
     for i, line in enumerate(lines):
         if "# Nested API structure" in line:
-            comment_idx = i
-            break
+            comment_indices.append(i)
 
-    if comment_idx is None:
+    if not comment_indices:
         print(f"  Warning: '# Nested API structure' comment not found in {client_file}")
         return False
 
@@ -185,30 +186,32 @@ def patch_ogx_client(client_file: Path, pairs: list[tuple[str, str]]) -> bool:
         if any(test_line in line for line in lines):
             return False
 
-    comment_line = lines[comment_idx]
-    indent = len(comment_line) - len(comment_line.lstrip())
-
-    patch_lines = [f"{' ' * indent}# Wire up parent-child API relationships\n"]
-    for parent_tag, child_tag in pairs:
-        parent_snake = to_snake_case(parent_tag)
-        child_snake = to_snake_case(child_tag)
-        patch_lines.append(f"{' ' * indent}self.{parent_snake}.{child_snake} = self.{child_snake}\n")
-        # Also add a short alias if the child name is prefixed with the parent name
-        # e.g., chat_completions -> chat.completions
-        if child_snake.startswith(f"{parent_snake}_"):
-            subresource_name = child_snake.removeprefix(f"{parent_snake}_")
-            patch_lines.append(
-                f"{' ' * indent}self.{parent_snake}.__dict__['{subresource_name}'] = self.{child_snake}\n"
-            )
-
-    insert_idx = comment_idx + 1
-    for line in reversed(patch_lines):
-        lines.insert(insert_idx, line)
+    # Patch each anchor (process in reverse so line indices remain valid)
+    for comment_idx in reversed(comment_indices):
+        comment_line = lines[comment_idx]
+        indent = len(comment_line) - len(comment_line.lstrip())
+
+        patch_lines = [f"{' ' * indent}# Wire up parent-child API relationships\n"]
+        for parent_tag, child_tag in pairs:
+            parent_snake = to_snake_case(parent_tag)
+            child_snake = to_snake_case(child_tag)
+            patch_lines.append(f"{' ' * indent}self.{parent_snake}.{child_snake} = self.{child_snake}\n")
+            # Also add a short alias if the child name is prefixed with the parent name
+            # e.g., chat_completions -> chat.completions
+            if child_snake.startswith(f"{parent_snake}_"):
+                subresource_name = child_snake.removeprefix(f"{parent_snake}_")
+                patch_lines.append(
+                    f"{' ' * indent}self.{parent_snake}.__dict__['{subresource_name}'] = self.{child_snake}\n"
+                )
+
+        insert_idx = comment_idx + 1
+        for line in reversed(patch_lines):
+            lines.insert(insert_idx, line)
 
     with open(client_file, "w") as f:
         f.writelines(lines)
 
-    print(f"  Patched OgxClient with {len(pairs)} parent-child relationships")
+    print(f"  Patched OgxClient and AsyncOgxClient with {len(pairs)} parent-child relationships each")
     return True
 
 

client-sdks/openapi/templates/python/__init__package.mustache

@@ -29,6 +29,7 @@ __all__ = [
     "OgxClient",
     "AsyncOgxClient",
     {{#apiInfo}}{{#apis}}"{{classname}}",
+    "Async{{classname}}",
     {{/apis}}{{/apiInfo}}"ApiResponse",
     "APIResponse",
     "ApiClient",

client-sdks/openapi/templates/python/api.mustache

@@ -18,9 +18,11 @@ from typing_extensions import Annotated
 {{/imports}}
 
 from {{packageName}}.api_client import ApiClient, RequestSerialized
+from {{packageName}}.async_api_client import AsyncApiClient
 from {{packageName}}.api_response import ApiResponse
 from {{packageName}}.rest import RESTResponseType
 from {{packageName}}.stream import Stream
+from {{packageName}}.async_stream import AsyncStream
 from {{packageName}}.lib._utils import pascal_to_snake_case
 
 
@@ -339,5 +341,148 @@ class {{classname}}:
     {{alias}} = {{target}}
 {{/vendorExtensions.x-operation-aliases}}
 
+{{/operation}}
+
+
+class Async{{classname}}({{classname}}):
+    """Async version of {{classname}}.
+
+    Inherits serialization and deserialization from {{classname}}.
+    Overrides HTTP methods to use async/await with AsyncApiClient.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = AsyncApiClient.get_default()
+        self.api_client = api_client
+        self.logger = logging.getLogger(Async{{classname}}.__name__)
+
+        # Child API attributes (set by AsyncOgxClient based on x-nesting-path)
+{{#operation}}{{#vendorExtensions.x-nesting-path}}{{#-first}}{{#tags}}{{#-first}}{{#vendorExtensions.x-nesting-path}}{{^-last}}        self.{{.}}: Any | None = None  # Next in nesting path
+{{/-last}}{{/vendorExtensions.x-nesting-path}}{{/-first}}{{/tags}}{{/-first}}{{/vendorExtensions.x-nesting-path}}{{/operation}}
+
+    def _create_event_stream(self, response_data: RESTResponseType, stream_type_name: str) -> AsyncStream[Any]:
+        """Create a typed async event stream from an SSE response.
+
+        Args:
+            response_data: The raw HTTP response containing the SSE stream.
+            stream_type_name: The schema name for the streaming response type.
+        """
+        stream_class = None
+        discriminator_map = None
+        discriminator_property = None
+        try:
+            module_name = pascal_to_snake_case(stream_type_name)
+            model_module = importlib.import_module('{{packageName}}.models.' + module_name)
+            stream_class = getattr(model_module, stream_type_name)
+            discriminator_map = getattr(stream_class, 'discriminator_value_class_map', None)
+            discriminator_property = getattr(stream_class, 'discriminator_property_name', None)
+        except (ImportError, ModuleNotFoundError, AttributeError) as e:
+            self.logger.debug(f"Could not import stream type {stream_type_name}: {e}")
+
+        def stream_decoder(data_str: str) -> Any:
+            if not data_str:
+                return None
+            try:
+                data = json.loads(data_str)
+            except json.JSONDecodeError:
+                return data_str
+
+            if discriminator_map and discriminator_property:
+                disc_value = data.get(discriminator_property, '')
+                variant_class_name = discriminator_map.get(disc_value)
+                if variant_class_name:
+                    try:
+                        variant_module_name = pascal_to_snake_case(variant_class_name)
+                        variant_module = importlib.import_module('{{packageName}}.models.' + variant_module_name)
+                        variant_class = getattr(variant_module, variant_class_name)
+                        return variant_class.from_dict(data)
+                    except Exception as e:
+                        self.logger.debug(f"Failed to deserialize as {variant_class_name}: {e}")
+
+            if stream_class is not None:
+                try:
+                    result = stream_class.from_dict(data)
+                    if hasattr(result, 'actual_instance') and result.actual_instance is not None:
+                        return result.actual_instance
+                    return result
+                except Exception as e:
+                    self.logger.debug(f"Failed to deserialize as {stream_type_name}: {e}")
+
+            return data
+
+        return AsyncStream(
+            response=response_data.response,
+            client=self.api_client,
+            decoder=stream_decoder,
+        )
+
+{{#operation}}
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}{{>partial_api_args}} -> {{#vendorExtensions.x-streaming}}{{#vendorExtensions.x-unwrap-list-response}}{{#returnType}}{{#returnContainer}}{{{returnBaseType}}} | AsyncStream[{{{returnBaseType}}}]{{/returnContainer}}{{^returnContainer}}{{{returnType}}} | AsyncStream[{{{returnType}}}]{{/returnContainer}}{{/returnType}}{{^returnType}}None | AsyncStream[None]{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{^vendorExtensions.x-unwrap-list-response}}{{{returnType}}}{{^returnType}}None{{/returnType}} | AsyncStream[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-unwrap-list-response}}{{/vendorExtensions.x-streaming}}{{^vendorExtensions.x-streaming}}{{#vendorExtensions.x-unwrap-list-response}}{{#returnType}}{{#returnContainer}}{{{returnBaseType}}}{{/returnContainer}}{{^returnContainer}}{{{returnType}}}{{/returnContainer}}{{/returnType}}{{^returnType}}None{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{^vendorExtensions.x-unwrap-list-response}}{{{returnType}}}{{^returnType}}None{{/returnType}}{{/vendorExtensions.x-unwrap-list-response}}{{/vendorExtensions.x-streaming}}:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+{{#vendorExtensions.x-streaming}}
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "{{vendorExtensions.x-streaming-type}}")
+
+{{/vendorExtensions.x-streaming}}
+        await response_data.aread()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        {{#vendorExtensions.x-unwrap-list-response}}
+        if _deserialized is not None and hasattr(_deserialized, 'data'):
+            return _deserialized.data
+        {{/vendorExtensions.x-unwrap-list-response}}
+        return _deserialized
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}_with_http_info{{>partial_api_args}} -> {{#vendorExtensions.x-streaming}}ApiResponse[{{{returnType}}}{{^returnType}}None{{/returnType}}] | AsyncStream[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-streaming}}{{^vendorExtensions.x-streaming}}ApiResponse[{{{returnType}}}{{^returnType}}None{{/returnType}}]{{/vendorExtensions.x-streaming}}:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+{{#vendorExtensions.x-streaming}}
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "{{vendorExtensions.x-streaming-type}}")
+
+{{/vendorExtensions.x-streaming}}
+        await response_data.aread()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    async def {{#vendorExtensions.x-operation-name}}{{vendorExtensions.x-operation-name}}{{/vendorExtensions.x-operation-name}}{{^vendorExtensions.x-operation-name}}{{operationId}}{{/vendorExtensions.x-operation-name}}_without_preload_content{{>partial_api_args}} -> RESTResponseType:
+{{>partial_api}}
+
+        response_data = await self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+{{#vendorExtensions.x-operation-aliases}}
+    {{alias}} = {{target}}
+{{/vendorExtensions.x-operation-aliases}}
+
 {{/operation}}
 {{/operations}}