PraisonAI 4.7.7__tar.gz → 4.7.9__tar.gz

{praisonai-4.7.7 → praisonai-4.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.7
+Version: 4.7.9
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,14 +11,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.7.5
-Requires-Dist: praisonai-code>=0.1.4
-Requires-Dist: praisonai-bot>=0.1.4
-Requires-Dist: praisonai-train>=0.1.4
-Requires-Dist: praisonai-browser>=0.1.4
-Requires-Dist: praisonai-mcp>=0.1.6
-Requires-Dist: praisonai-sandbox>=0.1.4
-Requires-Dist: praisonai-deploy>=0.1.4
+Requires-Dist: praisonaiagents>=1.7.7
+Requires-Dist: praisonai-code>=0.1.6
+Requires-Dist: praisonai-bot>=0.1.6
+Requires-Dist: praisonai-train>=0.1.6
+Requires-Dist: praisonai-browser>=0.1.6
+Requires-Dist: praisonai-mcp>=0.1.8
+Requires-Dist: praisonai-sandbox>=0.1.6
+Requires-Dist: praisonai-deploy>=0.1.6
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -140,6 +140,8 @@ Requires-Dist: agent-client-protocol>=0.7.0; extra == "acp"
 Provides-Extra: flow
 Requires-Dist: langflow>=1.0.0; extra == "flow"
 Requires-Dist: requests>=2.31.0; extra == "flow"
+Requires-Dist: a2a-sdk[http-server]>=1.0.0; extra == "flow"
+Requires-Dist: fastapi-pagination>=0.12.34; extra == "flow"
 Provides-Extra: lite
 Provides-Extra: all
 Requires-Dist: fastapi>=0.115.0; extra == "all"

{praisonai-4.7.7 → praisonai-4.7.9}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.7.7
+Version: 4.7.9
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,14 +11,14 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.7.5
-Requires-Dist: praisonai-code>=0.1.4
-Requires-Dist: praisonai-bot>=0.1.4
-Requires-Dist: praisonai-train>=0.1.4
-Requires-Dist: praisonai-browser>=0.1.4
-Requires-Dist: praisonai-mcp>=0.1.6
-Requires-Dist: praisonai-sandbox>=0.1.4
-Requires-Dist: praisonai-deploy>=0.1.4
+Requires-Dist: praisonaiagents>=1.7.7
+Requires-Dist: praisonai-code>=0.1.6
+Requires-Dist: praisonai-bot>=0.1.6
+Requires-Dist: praisonai-train>=0.1.6
+Requires-Dist: praisonai-browser>=0.1.6
+Requires-Dist: praisonai-mcp>=0.1.8
+Requires-Dist: praisonai-sandbox>=0.1.6
+Requires-Dist: praisonai-deploy>=0.1.6
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0
@@ -140,6 +140,8 @@ Requires-Dist: agent-client-protocol>=0.7.0; extra == "acp"
 Provides-Extra: flow
 Requires-Dist: langflow>=1.0.0; extra == "flow"
 Requires-Dist: requests>=2.31.0; extra == "flow"
+Requires-Dist: a2a-sdk[http-server]>=1.0.0; extra == "flow"
+Requires-Dist: fastapi-pagination>=0.12.34; extra == "flow"
 Provides-Extra: lite
 Provides-Extra: all
 Requires-Dist: fastapi>=0.115.0; extra == "all"

{praisonai-4.7.7 → praisonai-4.7.9}/PraisonAI.egg-info/requires.txt

@@ -1,14 +1,14 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.7.5
-praisonai-code>=0.1.4
-praisonai-bot>=0.1.4
-praisonai-train>=0.1.4
-praisonai-browser>=0.1.4
-praisonai-mcp>=0.1.6
-praisonai-sandbox>=0.1.4
-praisonai-deploy>=0.1.4
+praisonaiagents>=1.7.7
+praisonai-code>=0.1.6
+praisonai-bot>=0.1.6
+praisonai-train>=0.1.6
+praisonai-browser>=0.1.6
+praisonai-mcp>=0.1.8
+praisonai-sandbox>=0.1.6
+praisonai-deploy>=0.1.6
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0
@@ -153,6 +153,8 @@ praisonai-sandbox[e2b]
 [flow]
 langflow>=1.0.0
 requests>=2.31.0
+a2a-sdk[http-server]>=1.0.0
+fastapi-pagination>=0.12.34
 
 [gateway]
 praisonai-bot[gateway]

{praisonai-4.7.7 → praisonai-4.7.9}/praisonai/agents_generator.py

@@ -844,8 +844,11 @@ class AgentsGenerator:
         # Build tools dictionary using shared logic
         tools_dict = self._build_tools_dict(config)
         
-        # Select framework and resolve adapter variant
-        framework_name = self.framework or config.get('framework', 'praisonai')
+        # Select framework and resolve adapter variant. Registry is the single
+        # source of truth for the default, so no literal framework name here.
+        framework_name = self._adapter_registry.resolve_or_default(
+            self.framework or config.get('framework')
+        )
         adapter = self._select_framework(framework_name, config)
         
         # Validate framework availability through the injected registry so a
@@ -1376,10 +1379,13 @@ class AgentsGenerator:
         if self._is_workflow_yaml(config):
             # Bracket the workflow run in the same observability session the
             # sequential/hierarchical path uses so AgentOps init/finalize fires
-            # for workflow YAMLs too. Workflow YAMLs are native-only, so tag
-            # them 'praisonai'.
+            # for workflow YAMLs too. Tag with the config-resolved framework
+            # (registry default when omitted) rather than a hardcoded name.
             self._validate_workflow_cli_capabilities()
-            with observability_session("praisonai"):
+            workflow_label = self._adapter_registry.resolve_or_default(
+                self.framework or config.get('framework')
+            ).lower()
+            with observability_session(workflow_label):
                 return self._run_yaml_workflow(config)
 
         # Use shared preparation logic
@@ -1432,10 +1438,14 @@ class AgentsGenerator:
         if self._is_workflow_yaml(config):
             # Bracket the async workflow run in the same observability session
             # the sequential/hierarchical path uses so AgentOps init/finalize
-            # fires for workflow YAMLs too. Workflow YAMLs are native-only, so
-            # tag them 'praisonai'.
+            # fires for workflow YAMLs too. Tag with the config-resolved
+            # framework (registry default when omitted) rather than a hardcoded
+            # name.
             self._validate_workflow_cli_capabilities()
-            with observability_session("praisonai"):
+            workflow_label = self._adapter_registry.resolve_or_default(
+                self.framework or config.get('framework')
+            ).lower()
+            with observability_session(workflow_label):
                 return await self._arun_yaml_workflow(config)
 
         # Use shared preparation logic (off the event loop to avoid blocking imports)
@@ -1493,23 +1503,35 @@ class AgentsGenerator:
         )
         # Validate the YAML-declared framework first so a non-native workflow
         # YAML (e.g. framework: crewai) can't slip through just because the
-        # generator instance still holds the default 'praisonai'.
-        workflow_framework = framework_from_config(config)
+        # generator instance still holds the default 'praisonai'. Resolve
+        # through the injected registry (not the process default) so the
+        # build-time framework agrees with the observability label and a
+        # tenant-scoped adapter is honoured. Fall back to the process default
+        # when the instance was built without an injected registry.
+        registry = getattr(self, "_adapter_registry", None) or _get_default_adapter_registry()
+        workflow_framework = framework_from_config(
+            config, registry=registry
+        )
         validate_workflow_framework(
             workflow_framework,
             source="agents.yaml workflow section",
+            registry=registry,
         )
         if self.framework:
             validate_workflow_framework(
                 self.framework,
                 source="AgentsGenerator framework",
+                registry=registry,
             )
 
         # Parity with the sequential/hierarchical path: reject an incompatible
         # cli_backend in a workflow YAML at build time instead of accepting it
         # silently. Workflow YAMLs are native-only, so validate against
         # 'praisonai'.
-        self._validate_cli_backend_compatibility(config, workflow_framework or 'praisonai')
+        self._validate_cli_backend_compatibility(
+            config,
+            registry.resolve_or_default(workflow_framework),
+        )
 
         # The framework-level check above passes for 'praisonai' because the
         # sequential/hierarchical adapter does support cli_backend — but

{praisonai-4.7.7 → praisonai-4.7.9}/praisonai/api/agent_invoke.py

@@ -443,6 +443,42 @@ def _apply_agent_config(agent: Any, agent_config: Optional[Dict[str, Any]]) -> N
             )
 
 
+async def _safe_close_agent(agent: Any) -> None:
+    """Best-effort teardown of a per-request agent clone.
+
+    ``resolve_session_agent`` returns a fresh clone for every invoke of a
+    session-isolatable ``Agent`` (so concurrent callers never share
+    ``chat_history``). Those clones lazily spin up LLM client pools,
+    tool-executor threads and MCP subprocesses that
+    ``Agent.close()``/``aclose()`` release — without this teardown each request
+    leaks them into the long-lived server process.
+
+    Only a *clone* is closed. Ownership is derived from the agent itself via
+    :func:`_supports_session_isolation`: an isolatable agent was cloned for this
+    request and is safe to close, whereas a non-isolatable one (plain mock /
+    lightweight callable) is the shared registry instance and must NOT be closed
+    or the next request would run against a torn-down agent. Deriving ownership
+    from the resolved object — rather than comparing it against a second,
+    independently-timed registry lookup — is race-free even when the registry
+    entry is concurrently replaced.
+
+    Errors are swallowed (logged) so cleanup never masks a successful response.
+    """
+    if agent is None or not _supports_session_isolation(agent):
+        return
+    try:
+        aclose = getattr(agent, "aclose", None)
+        if inspect.iscoroutinefunction(aclose):
+            await aclose()
+        else:
+            close = getattr(agent, "close", None)
+            if callable(close):
+                import asyncio
+                await asyncio.to_thread(close)
+    except Exception:
+        logger.exception("Agent cleanup failed")
+
+
 def _supports_async_start(agent: Any) -> bool:
     """Return True if agent.astart is a coroutine function."""
     astart = getattr(agent, "astart", None)
@@ -511,52 +547,60 @@ if FASTAPI_AVAILABLE and APIRouter is not None:
                 status_code=404,
                 detail=f"Agent '{agent_id}' not found"
             )
-        
-        # Apply per-request agent_config overrides to the isolated clone, or
-        # reject unsupported keys with a 400 so the caller isn't silently
-        # running a different config than they asked for.
-        try:
-            _apply_agent_config(agent, request.agent_config)
-        except AgentConfigError as e:
-            raise HTTPException(status_code=400, detail=str(e))
 
         try:
-            # Session ID echoed back to the caller
-            session_id = request.session_id or "default"
-            
-            # Invoke agent (handle both sync and async agents)
-            if _supports_async_start(agent):
-                # Async agent
-                result = await agent.astart(request.message)
-            elif _supports_sync_start(agent):
-                # Sync agent - run in a worker thread to avoid blocking the event
-                # loop. ``asyncio.to_thread`` is the correct primitive inside a
-                # running request coroutine (``get_event_loop()`` is deprecated
-                # there since Python 3.10).
-                import asyncio
-                result = await asyncio.to_thread(agent.start, request.message)
-            else:
-                raise AttributeError(f"Agent {agent_id} must provide start() or async astart()")
-            
-            logger.info(f"Agent {agent_id} invoked successfully")
-            
-            return AgentInvokeResponse(
-                result=str(result),
-                session_id=session_id,
-                status="success",
-                metadata={
-                    "agent_id": agent_id,
-                    "message_length": len(request.message),
-                    "response_length": len(str(result))
-                }
-            )
-            
-        except Exception as e:
-            logger.error(f"Agent {agent_id} invocation failed: {e}")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Agent execution failed: {str(e)}"
-            )
+            # Apply per-request agent_config overrides to the isolated clone, or
+            # reject unsupported keys with a 400 so the caller isn't silently
+            # running a different config than they asked for.
+            try:
+                _apply_agent_config(agent, request.agent_config)
+            except AgentConfigError as e:
+                raise HTTPException(status_code=400, detail=str(e))
+
+            try:
+                # Session ID echoed back to the caller
+                session_id = request.session_id or "default"
+
+                # Invoke agent (handle both sync and async agents)
+                if _supports_async_start(agent):
+                    # Async agent
+                    result = await agent.astart(request.message)
+                elif _supports_sync_start(agent):
+                    # Sync agent - run in a worker thread to avoid blocking the event
+                    # loop. ``asyncio.to_thread`` is the correct primitive inside a
+                    # running request coroutine (``get_event_loop()`` is deprecated
+                    # there since Python 3.10).
+                    import asyncio
+                    result = await asyncio.to_thread(agent.start, request.message)
+                else:
+                    raise AttributeError(f"Agent {agent_id} must provide start() or async astart()")
+
+                logger.info(f"Agent {agent_id} invoked successfully")
+
+                return AgentInvokeResponse(
+                    result=str(result),
+                    session_id=session_id,
+                    status="success",
+                    metadata={
+                        "agent_id": agent_id,
+                        "message_length": len(request.message),
+                        "response_length": len(str(result))
+                    }
+                )
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"Agent {agent_id} invocation failed: {e}")
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Agent execution failed: {str(e)}"
+                )
+        finally:
+            # Release the per-request clone's resources (LLM pools, tool-executor
+            # threads, MCP subprocesses). No-op when the agent fell back to the
+            # shared template. Never masks the response.
+            await _safe_close_agent(agent)
 
     @router.get("/agents")
     async def list_agents(
@@ -669,6 +713,7 @@ async def invoke_agent_standalone(
             "available_agents": list_registered_agents()
         }
 
+    agent = None
     try:
         # Per-session isolated agent view (see resolve_session_agent). Done
         # inside the try so a clone/isolation failure returns a clean error
@@ -715,6 +760,10 @@ async def invoke_agent_standalone(
             "status": "error",
             "agent_id": agent_id
         }
+    finally:
+        # Release the per-request clone's resources; no-op for the shared
+        # template fallback. Never masks the response.
+        await _safe_close_agent(agent)
 
 
 # Example usage and helper functions

{praisonai-4.7.7 → praisonai-4.7.9}/praisonai/app/agentos.py

@@ -13,6 +13,16 @@ import os
 from praisonaiagents import AgentOSConfig, AgentOSProtocol
 
 
+def _run_to_dict(record: Any) -> Dict[str, Any]:
+    """A RunRecord as JSON. Uses whatever the record exposes rather than
+    assuming a shape, so a ledger with extra fields is not silently truncated."""
+    if hasattr(record, "as_dict"):
+        return record.as_dict()
+    if hasattr(record, "__dict__"):
+        return {k: v for k, v in vars(record).items() if not k.startswith("_")}
+    return {"run": str(record)}
+
+
 class AgentOS:
     """
     Production platform for deploying AI agents as web services.
@@ -139,7 +149,7 @@ class AgentOS:
     
     def _register_routes(self, app: Any) -> None:
         """Register API routes."""
-        from fastapi import HTTPException
+        from fastapi import HTTPException, Query
         from pydantic import BaseModel
         
         class ChatRequest(BaseModel):
@@ -166,6 +176,123 @@ class AgentOS:
         async def health():
             return {"status": "healthy"}
         
+        # ── Read endpoints ────────────────────────────────────────────────
+        # AgentOS could list agents and take a chat turn, and nothing else. A
+        # session could not be replayed, a run inspected, or a pending approval
+        # seen over HTTP, even though the protocols to expose all three already
+        # existed. These are READ-only on purpose: mutating a run over HTTP is a
+        # much larger design question than surfacing one.
+        #
+        # Each returns 503 with what to configure when its store is absent.
+        # Returning an empty list would be indistinguishable from "no runs yet",
+        # which is the failure this codebase keeps finding.
+
+        def _unavailable(what: str, how: str):
+            raise HTTPException(
+                status_code=503,
+                detail=f"{what} is not available: {how}",
+            )
+
+        @app.get(f"{self.config.api_prefix}/runs")
+        async def list_runs(limit: int = Query(50, ge=1, le=500)):
+            ledger = getattr(self, "run_ledger", None)
+            if ledger is None:
+                _unavailable(
+                    "Run history",
+                    "no run ledger is configured on this AgentOS instance. "
+                    "Attach a praisonaiagents.runs.SQLiteRunLedger as `run_ledger`.",
+                )
+            records = ledger.list_all(limit=limit)
+            return {"runs": [_run_to_dict(r) for r in records], "count": len(records)}
+
+        @app.get(f"{self.config.api_prefix}/runs/{{run_id}}")
+        async def get_run(run_id: str):
+            ledger = getattr(self, "run_ledger", None)
+            if ledger is None:
+                _unavailable(
+                    "Run history",
+                    "no run ledger is configured on this AgentOS instance.",
+                )
+            record = ledger.get(run_id)
+            if record is None:
+                raise HTTPException(status_code=404, detail=f"No run {run_id!r}")
+            return _run_to_dict(record)
+
+        @app.get(f"{self.config.api_prefix}/sessions")
+        async def list_sessions(limit: int = Query(20, ge=1, le=200)):
+            store = getattr(self, "session_store", None)
+            if store is None or not hasattr(store, "recent"):
+                _unavailable(
+                    "Session history",
+                    "no session store is configured on this AgentOS instance. "
+                    "Attach a praisonaiagents.session store as `session_store`.",
+                )
+            summaries = store.recent(limit=limit)
+            return {
+                "sessions": [
+                    s.as_dict() if hasattr(s, "as_dict") else dict(s) for s in summaries
+                ],
+                "count": len(summaries),
+            }
+
+        @app.get(f"{self.config.api_prefix}/sessions/{{session_id}}")
+        async def get_session(session_id: str, limit: int = Query(100, ge=1, le=500)):
+            store = getattr(self, "session_store", None)
+            if store is None:
+                _unavailable(
+                    "Session history",
+                    "no session store is configured on this AgentOS instance.",
+                )
+            if hasattr(store, "session_exists"):
+                if not store.session_exists(session_id):
+                    raise HTTPException(status_code=404, detail=f"No session {session_id!r}")
+            elif not store.get_chat_history(session_id, limit):
+                # Stores without session_exists cannot distinguish an unknown
+                # session from an empty one; treat an empty transcript as absent
+                # rather than returning a healthy-looking 200 for a bad id.
+                raise HTTPException(status_code=404, detail=f"No session {session_id!r}")
+            return {
+                "session_id": session_id,
+                "messages": store.get_chat_history(session_id, limit),
+            }
+
+        @app.get(f"{self.config.api_prefix}/approvals")
+        async def list_approvals():
+            try:
+                from praisonaiagents.approval import get_approval_registry
+            except ImportError:
+                _unavailable("Approvals", "praisonaiagents.approval is not installed.")
+            registry = get_approval_registry()
+
+            # The registry stores approval requirements across four fields --
+            # global tools plus per-agent overrides -- rather than a single
+            # dict. Reading the public accessors (is_required/get_risk_level)
+            # keeps this decoupled from that private shape. Fall back to the
+            # attributes only to enumerate which (agent, tool) pairs exist.
+            global_tools = getattr(registry, "_required_tools", None)
+            agent_tools = getattr(registry, "_agent_required_tools", None)
+            if global_tools is None and agent_tools is None:
+                _unavailable(
+                    "Approvals",
+                    "this build's approval registry exposes no requirement listing.",
+                )
+
+            requirements = []
+            for tool in sorted(global_tools or ()):
+                requirements.append({
+                    "tool": tool,
+                    "agent": None,
+                    "risk_level": registry.get_risk_level(tool),
+                })
+            for agent, tools in (agent_tools or {}).items():
+                for tool in sorted(tools):
+                    requirements.append({
+                        "tool": tool,
+                        "agent": agent,
+                        "risk_level": registry.get_risk_level(tool, agent),
+                    })
+            return {"requirements": requirements}
+
         @app.get(f"{self.config.api_prefix}/agents")
         async def list_agents():
             return {

{praisonai-4.7.7 → praisonai-4.7.9}/praisonai/capabilities/passthrough.py

@@ -7,7 +7,91 @@ Provides generic API passthrough functionality for provider-specific endpoints.
 from dataclasses import dataclass, field
 from typing import Optional, Any, Dict
 from urllib.parse import urlparse
+import asyncio
 import ipaddress
+import threading
+
+
+# Shared HTTP clients for the httpx fallback path (used when litellm's
+# passthrough route is unavailable). Reused across calls so the hot passthrough
+# fallback shares a keep-alive connection pool instead of opening + tearing down
+# a socket per agent call. Timeout is applied per-request, so a single client
+# safely serves callers with different ``timeout`` values.
+_sync_client: Any = None
+_async_client: Any = None
+_async_client_loop: Any = None
+_client_lock = threading.Lock()
+
+
+def _get_sync_client() -> Any:
+    """Return the shared sync httpx client, constructing it lazily."""
+    global _sync_client
+    if _sync_client is None:
+        with _client_lock:
+            if _sync_client is None:
+                import httpx
+                _sync_client = httpx.Client()
+    return _sync_client
+
+
+def _get_async_client() -> Any:
+    """Return the shared async httpx client for the running event loop.
+
+    ``httpx.AsyncClient`` binds its connection pool to the event loop that first
+    used it, so a client cached across separate ``asyncio.run()`` lifecycles (or
+    reused from a different loop) fails with a loop-closed error. We therefore
+    key the cached client to its owning loop and rebuild it whenever the current
+    loop differs from the one that created it.
+    """
+    global _async_client, _async_client_loop
+    import httpx
+
+    try:
+        current_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        current_loop = None
+
+    with _client_lock:
+        if _async_client is None or _async_client_loop is not current_loop:
+            _async_client = httpx.AsyncClient()
+            _async_client_loop = current_loop
+        return _async_client
+
+
+def close_clients() -> None:
+    """Close the cached sync client and clear the sync/async globals.
+
+    Provided as an explicit shutdown hook for long-lived hosts that want to
+    release the pooled sockets deterministically. The async client cannot be
+    awaited from this sync helper, so it is dropped (and rebuilt per-loop on next
+    use); the sync client is closed here.
+    """
+    global _sync_client, _async_client, _async_client_loop
+    with _client_lock:
+        if _sync_client is not None:
+            try:
+                _sync_client.close()
+            finally:
+                _sync_client = None
+        _async_client = None
+        _async_client_loop = None
+
+
+async def aclose_clients() -> None:
+    """Await-close the cached async client (in its own loop) and the sync one."""
+    global _sync_client, _async_client, _async_client_loop
+    client = None
+    with _client_lock:
+        client = _async_client
+        _async_client = None
+        _async_client_loop = None
+        if _sync_client is not None:
+            try:
+                _sync_client.close()
+            finally:
+                _sync_client = None
+    if client is not None:
+        await client.aclose()
 
 
 @dataclass
@@ -121,22 +205,20 @@ def passthrough(
             metadata=metadata or {},
         )
     except AttributeError:
-        # Fallback to httpx if passthrough not available
-        import httpx
-        
+        # Fallback to a shared httpx client if the passthrough route is missing.
         url = f"{_validate_api_base(api_base) if api_base else 'https://api.openai.com'}{endpoint}"
         request_headers = headers or {}
         if api_key:
             request_headers['Authorization'] = f"Bearer {api_key}"
         
-        with httpx.Client(timeout=timeout) as client:
-            response = client.request(
-                method=method,
-                url=url,
-                headers=request_headers,
-                json=json_data,
-                data=data,
-            )
+        response = _get_sync_client().request(
+            method=method,
+            url=url,
+            headers=request_headers,
+            json=json_data,
+            data=data,
+            timeout=timeout,
+        )
         
         return PassthroughResult(
             data=response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,
@@ -203,21 +285,19 @@ async def apassthrough(
             metadata=metadata or {},
         )
     except AttributeError:
-        import httpx
-        
         url = f"{_validate_api_base(api_base) if api_base else 'https://api.openai.com'}{endpoint}"
         request_headers = headers or {}
         if api_key:
             request_headers['Authorization'] = f"Bearer {api_key}"
         
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.request(
-                method=method,
-                url=url,
-                headers=request_headers,
-                json=json_data,
-                data=data,
-            )
+        response = await _get_async_client().request(
+            method=method,
+            url=url,
+            headers=request_headers,
+            json=json_data,
+            data=data,
+            timeout=timeout,
+        )
         
         return PassthroughResult(
             data=response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,