fix(client-sdks): guard call_api patch for stainless SDK fallback compatibility

The call_api patch in OGXAsLibraryClient.__init__ unconditionally
accessed self.api_client.call_api, but the stainless SDK OgxClient
does not have an api_client attribute. Guard with hasattr checks so
the fallback to the stainless SDK (which uses the request() override
instead) still works.

Also add try/except fallback for the ogx_open_client.rest import in
_async_in_process_call to avoid ModuleNotFoundError when only the
stainless SDK is installed.

Signed-off-by: E Geiger <egeiger@redhat.com>

Author: aegeiger

src/ogx/core/library_client.py

@@ -219,8 +219,10 @@ def __init__(
         # Patch api_client.call_api to route requests in-process instead of over HTTP.
         # The generated SDK's call chain is: API method → api_client.call_api() → rest.request() → httpx.
         # We intercept at call_api so the request never reaches httpx/network.
-        self._original_call_api = self.api_client.call_api
-        self.api_client.call_api = self._in_process_call_api  # type: ignore[method-assign]
+        # Only applies to ogx_open_client; the stainless SDK uses a request() override instead.
+        if hasattr(self, "api_client") and hasattr(self.api_client, "call_api"):
+            self._original_call_api = self.api_client.call_api
+            self.api_client.call_api = self._in_process_call_api  # type: ignore[method-assign]
 
     def _run_event_loop(self) -> None:
         """Runs forever in the background thread."""
@@ -412,7 +414,11 @@ async def _async_in_process_call(
         from urllib.parse import urlparse
 
         from fastapi.responses import StreamingResponse
-        from ogx_open_client.rest import RESTResponse
+
+        try:
+            from ogx_open_client.rest import RESTResponse
+        except ImportError:
+            from ogx_client.rest import RESTResponse  # type: ignore[assignment]
 
         async_client = self.async_client
         assert async_client.route_impls is not None, "Client not initialized"
@@ -493,7 +499,12 @@ async def _async_in_process_call(
 
             # Build the response
             if isinstance(result, StreamingResponse):
-                # Streaming response — collect SSE chunks into a sync-iterable response
+                # Streaming response — collect SSE chunks into a sync-iterable response.
+                # TODO: This buffers the entire stream before returning, losing time-to-first-token
+                # benefits. For true incremental streaming, we'd need a SyncByteStream adapter that
+                # bridges the async generator to sync iter_bytes() via a queue (similar to
+                # _stream_request). Acceptable for now since in-process library mode is primarily
+                # used for testing, not latency-sensitive production streaming.
                 content_type = result.media_type or "text/event-stream"
 
                 # Collect all chunks from the async generator