Add LiteLlm + TemporalModel integration test and sandbox fix

Add litellm and httpx to the GoogleAdkPlugin sandbox passthrough
modules. Without this, any LiteLlm-backed model crashes inside the
workflow sandbox because litellm transitively imports httpx which
fails sandbox restrictions.

Add an integration test proving LiteLlm works with TemporalModel
through the full Temporal workflow path, using a fake litellm custom
provider that requires no API key.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: xumaple

temporalio/contrib/google_adk_agents/_plugin.py

@@ -62,7 +62,7 @@ class GoogleAdkPlugin(SimplePlugin):
 
     This plugin configures:
     - Pydantic Payload Converter (required for ADK objects).
-    - Sandbox Passthrough for google.adk and google.genai modules.
+    - Sandbox Passthrough for ADK and its dependencies.
     """
 
     def __init__(
@@ -89,7 +89,7 @@ def workflow_runner(runner: WorkflowRunner | None) -> WorkflowRunner:
                 return dataclasses.replace(
                     runner,
                     restrictions=runner.restrictions.with_passthrough_modules(
-                        "google.adk", "google.genai", "mcp"
+                        "google.adk", "google.genai", "mcp", "litellm", "httpx"
                     ),
                 )
             return runner

tests/contrib/google_adk_agents/test_google_adk_agents.py

@@ -664,6 +664,15 @@ async def test_mcp_toolset_outside_workflow_no_not_in_workflow_toolset():
         await toolset.get_tools()
 
 
+try:
+    import litellm as _litellm_check
+
+    del _litellm_check
+    _has_litellm = True
+except ImportError:
+    _has_litellm = False
+
+
 complex_activity_inputs_seen: dict[str, object] = {}
 
 
@@ -855,3 +864,116 @@ async def test_activity_tool_supports_complex_inputs_via_adk(client: Client):
             ),
             "annotate_trip": "SFO->LAX:3",
         }
+
+
+def litellm_agent(model_name: str) -> Agent:
+    return Agent(
+        name="litellm_test_agent",
+        model=TemporalModel(model_name),
+    )
+
+
+@workflow.defn
+class LiteLlmAgent:
+    @workflow.run
+    async def run(self, prompt: str, model_name: str) -> Event | None:
+        agent = litellm_agent(model_name)
+
+        runner = InMemoryRunner(
+            agent=agent,
+            app_name="litellm_test_app",
+        )
+
+        session = await runner.session_service.create_session(
+            app_name="litellm_test_app", user_id="test"
+        )
+
+        last_event = None
+        async with Aclosing(
+            runner.run_async(
+                user_id="test",
+                session_id=session.id,
+                new_message=types.Content(role="user", parts=[types.Part(text=prompt)]),
+            )
+        ) as agen:
+            async for event in agen:
+                last_event = event
+
+        return last_event
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(not _has_litellm, reason="litellm not installed")
+async def test_litellm_model(client: Client):
+    """Test that ADK's LiteLlm class works with TemporalModel through a full Temporal workflow."""
+    # Import inside the test so the module loads cleanly when litellm is not installed.
+    import litellm as litellm_module
+    from google.adk.models.lite_llm import LiteLlm
+    from google.adk.models.registry import _llm_registry_dict
+    from litellm import ModelResponse
+    from litellm.llms.custom_llm import CustomLLM
+
+    class FakeLiteLlmProvider(CustomLLM):
+        """A fake litellm provider that returns canned responses locally."""
+
+        def _make_response(self, model: str) -> ModelResponse:
+            return ModelResponse(
+                choices=[
+                    {
+                        "message": {
+                            "content": "hello from litellm",
+                            "role": "assistant",
+                        },
+                        "index": 0,
+                        "finish_reason": "stop",
+                    }
+                ],
+                model=model,
+            )
+
+        def completion(self, *args: Any, **kwargs: Any) -> ModelResponse:
+            model = args[0] if args else kwargs.get("model", "unknown")
+            return self._make_response(model)
+
+        async def acompletion(self, *args: Any, **kwargs: Any) -> ModelResponse:
+            model = args[0] if args else kwargs.get("model", "unknown")
+            return self._make_response(model)
+
+    # Register our fake provider with litellm
+    litellm_module.custom_provider_map = [
+        {"provider": "fake", "custom_handler": FakeLiteLlmProvider()}
+    ]
+
+    try:
+        # Register LiteLlm to handle "fake/.*" model names via ADK's LLMRegistry
+        _llm_registry_dict[r"fake/.*"] = LiteLlm
+        # Clear the resolve LRU cache so the new pattern is picked up
+        LLMRegistry.resolve.cache_clear()
+        new_config = client.config()
+        new_config["plugins"] = [GoogleAdkPlugin()]
+        client = Client(**new_config)
+
+        async with Worker(
+            client,
+            task_queue="adk-task-queue-litellm",
+            workflows=[LiteLlmAgent],
+            max_cached_workflows=0,
+        ):
+            handle = await client.start_workflow(
+                LiteLlmAgent.run,
+                args=["Say hello", "fake/test-model"],
+                id=f"litellm-agent-workflow-{uuid.uuid4()}",
+                task_queue="adk-task-queue-litellm",
+                execution_timeout=timedelta(seconds=60),
+            )
+            result = await handle.result()
+
+        assert result is not None
+        assert result.content is not None
+        assert result.content.parts is not None
+        assert result.content.parts[0].text == "hello from litellm"
+    finally:
+        # Clean up registry state
+        _llm_registry_dict.pop(r"fake/.*", None)
+        LLMRegistry.resolve.cache_clear()
+        litellm_module.custom_provider_map = []