Merge branch 'main' into NEXUS-283

Author: tconley1428

.github/workflows/ci.yml

@@ -163,7 +163,7 @@ jobs:
       - run: poe build-develop
       - run: poe lint
       - run: mkdir junit-xml
-      - run: poe test  -s --junit-xml=junit-xml/latest-deps.xml
+      - run: poe test -s --junit-xml=junit-xml/latest-deps.xml
         timeout-minutes: 15
       - name: "Upload junit-xml artifacts"
         uses: actions/upload-artifact@v4

README.md

@@ -2066,6 +2066,13 @@ To execute tests:
 poe test
 ```
 
+`poe test` spreads tests across multiple worker processes by default. If you
+need a serial run for debugging, invoke pytest directly:
+
+```bash
+uv run pytest
+```
+
 This runs against [Temporalite](https://github.com/temporalio/temporalite). To run against the time-skipping test
 server, pass `--workflow-environment time-skipping`. To run against the `default` namespace of an already-running
 server, pass the `host:port` to `--workflow-environment`. Can also use regular pytest arguments. For example, here's how

pyproject.toml

@@ -75,7 +75,9 @@ dev = [
   "openinference-instrumentation-google-adk>=0.1.8",
   "googleapis-common-protos==1.70.0",
   "pytest-rerunfailures>=16.1",
+  "pytest-xdist>=3.6,<4",
   "moto[s3,server]>=5",
+  "setuptools<82",
   "opentelemetry-exporter-otlp-proto-grpc>=1.11.1,<2",
   "opentelemetry-semantic-conventions>=0.40b0,<1",
   "opentelemetry-sdk-extension-aws>=2.0.0,<3",
@@ -118,7 +120,7 @@ lint-types = [
   { cmd = "uv run basedpyright" },
 ]
 run-bench = "uv run python scripts/run_bench.py"
-test = "uv run pytest"
+test = "uv run pytest -n auto --dist=worksteal"
 
 
 [tool.pytest.ini_options]

temporalio/contrib/google_adk_agents/README.md

@@ -118,35 +118,44 @@ from temporalio.worker import Worker
 from temporalio.contrib.google_adk_agents import (
     GoogleAdkPlugin,
     TemporalMcpToolSetProvider,
-    TemporalMcpToolSet
+    TemporalMcpToolSet,
 )
 
-# Create toolset provider
-provider = TemporalMcpToolSetProvider("my-tools",
-                                      lambda _: McpToolset(
-                                          connection_params=StdioConnectionParams(
-                                              server_params=StdioServerParameters(
-                                                  command="npx",
-                                                  args=[
-                                                      "-y",
-                                                      "@modelcontextprotocol/server-filesystem",
-                                                      os.path.dirname(os.path.abspath(__file__)),
-                                                  ],
-                                              ),
-                                          ),
-                                      ))
+
+def toolset_factory(_):
+    return McpToolset(
+        connection_params=StdioConnectionParams(
+            server_params=StdioServerParameters(
+                command="npx",
+                args=[
+                    "-y",
+                    "@modelcontextprotocol/server-filesystem",
+                    os.path.dirname(os.path.abspath(__file__)),
+                ],
+            ),
+        ),
+    )
 
 # Use in agent workflow
 agent = Agent(
     name="test_agent",
     model="gemini-2.5-pro",
-    tools=[TemporalMcpToolSet("my-tools")]
+    tools=[
+        TemporalMcpToolSet(
+            "my-tools",
+            not_in_workflow_toolset=toolset_factory,
+        )
+    ],
 )
 
 client = await Client.connect(
     "localhost:7233",
     plugins=[
-        GoogleAdkPlugin(toolset_providers=[provider]),
+        GoogleAdkPlugin(
+            toolset_providers=[
+                TemporalMcpToolSetProvider("my-tools", toolset_factory),
+            ],
+        ),
     ],
 )
 
@@ -157,6 +166,35 @@ worker = Worker(
 )
 ```
 
+### Local ADK Runs
+
+The same agent definitions can also be exercised outside Temporal with
+`adk run` or `adk web`.
+
+- `TemporalModel` and `activity_tool(...)` work in local ADK runs without
+  additional configuration.
+- If the agent uses `TemporalMcpToolSet`, define a shared toolset factory,
+  register it with `TemporalMcpToolSetProvider(...)` for workflow runs, and
+  reuse the same function for `not_in_workflow_toolset=...` so the agent can
+  fall back to the underlying `McpToolset` when it is not running inside
+  `workflow.in_workflow()`.
+
+Example:
+
+```python
+# Reuse the same toolset_factory registered in GoogleAdkPlugin above.
+agent = Agent(
+    name="test_agent",
+    model=TemporalModel("gemini-2.5-pro"),
+    tools=[
+        TemporalMcpToolSet(
+            "my-tools",
+            not_in_workflow_toolset=toolset_factory,
+        )
+    ],
+)
+```
+
 ## Integration Points
 
 This integration provides comprehensive support for running Google ADK Agents within Temporal workflows while maintaining:

temporalio/contrib/google_adk_agents/_mcp.py

@@ -90,7 +90,9 @@ class TemporalMcpToolSetProvider:
     within Temporal workflows.
     """
 
-    def __init__(self, name: str, toolset_factory: Callable[[Any | None], McpToolset]):
+    def __init__(
+        self, name: str, toolset_factory: Callable[[Any | None], McpToolset]
+    ) -> None:
         """Initializes the toolset provider.
 
         Args:
@@ -215,20 +217,28 @@ def __init__(
         name: str,
         config: ActivityConfig | None = None,
         factory_argument: Any | None = None,
+        not_in_workflow_toolset: Callable[[Any | None], McpToolset] | None = None,
     ):
         """Initializes the Temporal MCP toolset.
 
         Args:
             name: Name of the toolset (used for activity naming).
             config: Optional activity configuration.
             factory_argument: Optional argument passed to toolset factory.
+            not_in_workflow_toolset: Optional factory that returns the
+                underlying ``McpToolset`` to use when this wrapper executes
+                outside ``workflow.in_workflow()``, such as local ADK runs.
+                This is not needed during normal workflow execution, but
+                ``get_tools()`` raises ``ValueError`` outside a workflow if it
+                is omitted.
         """
         super().__init__()
         self._name = name
         self._factory_argument = factory_argument
         self._config = config or ActivityConfig(
             start_to_close_timeout=timedelta(minutes=1)
         )
+        self._not_in_workflow_toolset = not_in_workflow_toolset
 
     async def get_tools(
         self, readonly_context: ReadonlyContext | None = None
@@ -241,6 +251,17 @@ async def get_tools(
         Returns:
             List of available tools wrapped as Temporal activities.
         """
+        # If executed outside a workflow, like when doing local adk runs, use the mcp server directly
+        if not workflow.in_workflow():
+            if self._not_in_workflow_toolset is None:
+                raise ValueError(
+                    "Attempted to use TemporalMcpToolSet outside a workflow, but "
+                    "no not_in_workflow_toolset was provided. Either use "
+                    "McpToolSet directly or pass a factory that returns the "
+                    "underlying McpToolset for non-workflow execution."
+                )
+            return await self._not_in_workflow_toolset(None).get_tools(readonly_context)
+
         tool_results: list[_ToolResult] = await workflow.execute_activity(
             self._name + "-list-tools",
             _GetToolsArguments(self._factory_argument),

temporalio/contrib/google_adk_agents/_model.py

@@ -5,6 +5,7 @@
 from google.adk.models.llm_request import LlmRequest
 from google.adk.models.llm_response import LlmResponse
 
+import temporalio.workflow
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
 
@@ -67,6 +68,14 @@ async def generate_content_async(
         Yields:
             The responses from the model.
         """
+        # If executed outside a workflow, like when doing local adk runs, use the model directly
+        if not temporalio.workflow.in_workflow():
+            async for response in LLMRegistry.new_llm(
+                self._model_name
+            ).generate_content_async(llm_request, stream=stream):
+                yield response
+            return
+
         responses = await workflow.execute_activity(
             invoke_model,
             args=[llm_request],

temporalio/contrib/google_adk_agents/workflow.py

@@ -3,6 +3,7 @@
 import inspect
 from typing import Any, Callable
 
+import temporalio.workflow
 from temporalio import workflow
 
 
@@ -29,6 +30,14 @@ async def wrapper(*args: Any, **kw: Any):
         # Decorator kwargs are defaults.
         options = kwargs.copy()
 
+        if not temporalio.workflow.in_workflow():
+            # If executed outside a workflow, like when doing local adk runs, use the function directly
+            result = activity_def(*args, **kw)
+            if inspect.isawaitable(result):
+                return await result
+            else:
+                return result
+
         return await workflow.execute_activity(activity_def, *activity_args, **options)
 
     # Copy metadata

tests/conftest.py

@@ -187,9 +187,16 @@ async def worker(
 @pytest.hookimpl(hookwrapper=True, trylast=True)
 def pytest_cmdline_main(config):  # type: ignore[reportMissingParameterType, reportUnusedParameter]
     result = yield
-    if result.get_result() == 0:
+    exit_code = result.get_result()
+    numprocesses = getattr(config.option, "numprocesses", None)
+    running_with_xdist = hasattr(config, "workerinput") or numprocesses not in (
+        None,
+        0,
+        "0",
+    )
+    if exit_code == 0 and not running_with_xdist:
         os._exit(0)
-    return result.get_result()
+    return exit_code
 
 
 CONTINUE_AS_NEW_SUGGEST_HISTORY_COUNT = 50