langroid 0.58.1__tar.gz → 0.58.3__tar.gz

{langroid-0.58.1 → langroid-0.58.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.58.1
+Version: 0.58.3
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -94,8 +94,8 @@ Requires-Dist: chainlit<3.0.0,>=2.0.1; extra == 'chainlit'
 Requires-Dist: python-socketio<6.0.0,>=5.11.0; extra == 'chainlit'
 Provides-Extra: chromadb
 Requires-Dist: chromadb<=0.4.23,>=0.4.21; extra == 'chromadb'
-Provides-Extra: crawl-4-ai
-Requires-Dist: crawl4ai>=0.6.3; extra == 'crawl-4-ai'
+Provides-Extra: crawl4ai
+Requires-Dist: crawl4ai>=0.6.3; extra == 'crawl4ai'
 Provides-Extra: db
 Requires-Dist: psycopg2-binary>=2.9.10; extra == 'db'
 Requires-Dist: psycopg2<3.0.0,>=2.9.7; extra == 'db'

{langroid-0.58.1 → langroid-0.58.3}/langroid/language_models/client_cache.py

@@ -49,6 +49,8 @@ def get_openai_client(
     organization: Optional[str] = None,
     timeout: Union[float, Timeout] = 120.0,
     default_headers: Optional[Dict[str, str]] = None,
+    http_client: Optional[Any] = None,
+    http_client_config: Optional[Dict[str, Any]] = None,
 ) -> OpenAI:
     """
     Get or create a singleton OpenAI client with the given configuration.
@@ -59,6 +61,8 @@ def get_openai_client(
         organization: Optional organization ID
         timeout: Request timeout
         default_headers: Optional default headers
+        http_client: Optional httpx.Client instance
+        http_client_config: Optional config dict for creating httpx.Client
 
     Returns:
         OpenAI client instance
@@ -66,6 +70,32 @@ def get_openai_client(
     if isinstance(timeout, (int, float)):
         timeout = Timeout(timeout)
 
+    # If http_client is provided directly, don't cache (complex object)
+    if http_client is not None:
+        client = OpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            organization=organization,
+            timeout=timeout,
+            default_headers=default_headers,
+            http_client=http_client,
+        )
+        _all_clients.add(client)
+        return client
+
+    # If http_client_config is provided, create client from config and cache
+    created_http_client = None
+    if http_client_config is not None:
+        try:
+            from httpx import Client
+
+            created_http_client = Client(**http_client_config)
+        except ImportError:
+            raise ValueError(
+                "httpx is required to use http_client_config. "
+                "Install it with: pip install httpx"
+            )
+
     cache_key = _get_cache_key(
         "openai",
         api_key=api_key,
@@ -73,6 +103,7 @@ def get_openai_client(
         organization=organization,
         timeout=timeout,
         default_headers=default_headers,
+        http_client_config=http_client_config,  # Include config in cache key
     )
 
     if cache_key in _client_cache:
@@ -84,6 +115,7 @@ def get_openai_client(
         organization=organization,
         timeout=timeout,
         default_headers=default_headers,
+        http_client=created_http_client,  # Use the client created from config
     )
 
     _client_cache[cache_key] = client
@@ -97,6 +129,8 @@ def get_async_openai_client(
     organization: Optional[str] = None,
     timeout: Union[float, Timeout] = 120.0,
     default_headers: Optional[Dict[str, str]] = None,
+    http_client: Optional[Any] = None,
+    http_client_config: Optional[Dict[str, Any]] = None,
 ) -> AsyncOpenAI:
     """
     Get or create a singleton AsyncOpenAI client with the given configuration.
@@ -107,6 +141,8 @@ def get_async_openai_client(
         organization: Optional organization ID
         timeout: Request timeout
         default_headers: Optional default headers
+        http_client: Optional httpx.AsyncClient instance
+        http_client_config: Optional config dict for creating httpx.AsyncClient
 
     Returns:
         AsyncOpenAI client instance
@@ -114,6 +150,32 @@ def get_async_openai_client(
     if isinstance(timeout, (int, float)):
         timeout = Timeout(timeout)
 
+    # If http_client is provided directly, don't cache (complex object)
+    if http_client is not None:
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            organization=organization,
+            timeout=timeout,
+            default_headers=default_headers,
+            http_client=http_client,
+        )
+        _all_clients.add(client)
+        return client
+
+    # If http_client_config is provided, create async client from config and cache
+    created_http_client = None
+    if http_client_config is not None:
+        try:
+            from httpx import AsyncClient
+
+            created_http_client = AsyncClient(**http_client_config)
+        except ImportError:
+            raise ValueError(
+                "httpx is required to use http_client_config. "
+                "Install it with: pip install httpx"
+            )
+
     cache_key = _get_cache_key(
         "async_openai",
         api_key=api_key,
@@ -121,6 +183,7 @@ def get_async_openai_client(
         organization=organization,
         timeout=timeout,
         default_headers=default_headers,
+        http_client_config=http_client_config,  # Include config in cache key
     )
 
     if cache_key in _client_cache:
@@ -132,6 +195,7 @@ def get_async_openai_client(
         organization=organization,
         timeout=timeout,
         default_headers=default_headers,
+        http_client=created_http_client,  # Use the client created from config
     )
 
     _client_cache[cache_key] = client

{langroid-0.58.1 → langroid-0.58.3}/langroid/language_models/openai_gpt.py

@@ -287,6 +287,9 @@ class OpenAIGPTConfig(LLMConfig):
     langdb_params: LangDBParams = LangDBParams()
     portkey_params: PortkeyParams = PortkeyParams()
     headers: Dict[str, str] = {}
+    http_client_factory: Optional[Callable[[], Any]] = None  # Factory for httpx.Client
+    http_verify_ssl: bool = True  # Simple flag for SSL verification
+    http_client_config: Optional[Dict[str, Any]] = None  # Config dict for httpx.Client
 
     def __init__(self, **kwargs) -> None:  # type: ignore
         local_model = "api_base" in kwargs and kwargs["api_base"] is not None
@@ -631,6 +634,32 @@ class OpenAIGPT(LanguageModel):
                 # Add Portkey-specific headers
                 self.config.headers.update(self.config.portkey_params.get_headers())
 
+            # Create http_client if needed - Priority order:
+            # 1. http_client_factory (most flexibility, not cacheable)
+            # 2. http_client_config (cacheable, moderate flexibility)
+            # 3. http_verify_ssl=False (cacheable, simple SSL bypass)
+            http_client = None
+            async_http_client = None
+            http_client_config_used = None
+
+            if self.config.http_client_factory is not None:
+                # Use the factory to create http_client (not cacheable)
+                http_client = self.config.http_client_factory()
+                # Don't set async_http_client from sync client - create separately
+                # This avoids type mismatch issues
+                async_http_client = None
+            elif self.config.http_client_config is not None:
+                # Use config dict (cacheable)
+                http_client_config_used = self.config.http_client_config
+            elif not self.config.http_verify_ssl:
+                # Simple SSL bypass (cacheable)
+                http_client_config_used = {"verify": False}
+                logging.warning(
+                    "SSL verification has been disabled. This is insecure and "
+                    "should only be used in trusted environments (e.g., "
+                    "corporate networks with self-signed certificates)."
+                )
+
             if self.config.use_cached_client:
                 self.client = get_openai_client(
                     api_key=self.api_key,
@@ -638,6 +667,8 @@ class OpenAIGPT(LanguageModel):
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
+                    http_client=http_client,
+                    http_client_config=http_client_config_used,
                 )
                 self.async_client = get_async_openai_client(
                     api_key=self.api_key,
@@ -645,23 +676,56 @@ class OpenAIGPT(LanguageModel):
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
+                    http_client=async_http_client,
+                    http_client_config=http_client_config_used,
                 )
             else:
                 # Create new clients without caching
-                self.client = OpenAI(
+                client_kwargs: Dict[str, Any] = dict(
                     api_key=self.api_key,
                     base_url=self.api_base,
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
                 )
-                self.async_client = AsyncOpenAI(
+                if http_client is not None:
+                    client_kwargs["http_client"] = http_client
+                elif http_client_config_used is not None:
+                    # Create http_client from config for non-cached scenario
+                    try:
+                        from httpx import Client
+
+                        client_kwargs["http_client"] = Client(**http_client_config_used)
+                    except ImportError:
+                        raise ValueError(
+                            "httpx is required to use http_client_config. "
+                            "Install it with: pip install httpx"
+                        )
+                self.client = OpenAI(**client_kwargs)
+
+                async_client_kwargs: Dict[str, Any] = dict(
                     api_key=self.api_key,
                     base_url=self.api_base,
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
                 )
+                if async_http_client is not None:
+                    async_client_kwargs["http_client"] = async_http_client
+                elif http_client_config_used is not None:
+                    # Create async http_client from config for non-cached scenario
+                    try:
+                        from httpx import AsyncClient
+
+                        async_client_kwargs["http_client"] = AsyncClient(
+                            **http_client_config_used
+                        )
+                    except ImportError:
+                        raise ValueError(
+                            "httpx is required to use http_client_config. "
+                            "Install it with: pip install httpx"
+                        )
+                self.async_client = AsyncOpenAI(**async_client_kwargs)
 
         self.cache: CacheDB | None = None
         use_cache = self.config.cache_config is not None

{langroid-0.58.1 → langroid-0.58.3}/langroid/parsing/url_loader.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
         from crawl4ai.extraction_strategy import ExtractionStrategy
         from crawl4ai.markdown_generation_strategy import MarkdownGenerationStrategy
     except ImportError:
-        raise LangroidImportError("crawl4ai", "crawl-4-ai")
+        raise LangroidImportError("crawl4ai", "crawl4ai")
 
 load_dotenv()
 

{langroid-0.58.1 → langroid-0.58.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.58.1"
+version = "0.58.3"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]
@@ -270,7 +270,7 @@ asyncio = [
 firecrawl = [
     "firecrawl-py>=1.13.5",
 ]
-crawl-4-ai = [
+crawl4ai = [
     "crawl4ai>=0.6.3",
 ]