Merge remote-tracking branch 'origin/main' into fix-mcp-dependency-declarations

# Conflicts:
#	pyproject.toml
#	uv.lock

Author: brianstrauch

README.md

@@ -93,6 +93,7 @@ Some examples require extra dependencies. See each sample's directory for specif
   This contains two samples, one sending messages to an existing workflow and a second that creates a workflow through Nexus
   and sends messages to it.
 * [nexus_multiple_args](nexus_multiple_args) - Map a Nexus operation to a handler workflow that takes multiple arguments.
+* [nexus_standalone_activity](nexus_standalone_activity) - Back a Nexus operation with a standalone Activity.
 * [nexus_standalone_operations](nexus_standalone_operations) - Execute Nexus operations directly from client code,
 without wrapping them in a workflow.
 * [open_telemetry](open_telemetry) - Trace workflows with OpenTelemetry.

google_adk_agents/README.md

@@ -43,7 +43,7 @@ Each directory contains a complete example with its own README:
 | --- | --- |
 | [basic](./basic/README.md) | A single ADK agent with `TemporalModel` and one model call — no tools. The minimal end-to-end example. |
 | [chatbot](./chatbot/README.md) | A multi-turn conversation over one persisted ADK session, with each turn driven by a workflow Update handler that returns the assistant's reply. |
-| [tools](./tools/README.md) | A Temporal activity wrapped as an ADK tool with `activity_tool`, so tool calls run as their own activities. |
+| [tools](./tools/README.md) | A Temporal activity wrapped as an ADK tool with `activity_as_tool`, so tool calls run as their own activities. |
 | [agent_patterns](./agent_patterns/README.md) | A coordinator `LlmAgent` with `sub_agents`, each a `TemporalModel` with a per-agent activity summary. |
 | [mcp](./mcp/README.md) | A local echo MCP toolset via `TemporalMcpToolSet` / `TemporalMcpToolSetProvider`, running MCP tools as activities. Self-contained, no Node required. |
 | [streaming](./streaming/README.md) | Token streaming via `TemporalModel(streaming_topic=...)` + `WorkflowStream`, consumed by a starter with `WorkflowStreamClient`. |

google_adk_agents/tools/README.md

@@ -1,7 +1,7 @@
 # Tools — Temporal Activities as ADK Tools
 
 A weather agent whose `get_weather` Temporal activity is wrapped as an ADK tool
-with `activity_tool(...)`. The model decides to call the tool; the tool runs as
+with `activity_as_tool(...)`. The model decides to call the tool; the tool runs as
 its own Temporal activity — retryable and observable — rather than inline in the
 workflow. This demonstrates the activity boundary for tool calls.
 

google_adk_agents/tools/workflows/weather_workflow.py

@@ -16,9 +16,9 @@
 class WeatherAgentWorkflow:
     @workflow.run
     async def run(self, prompt: str) -> str:
-        # activity_tool runs the tool call as a real Temporal activity, so it's
+        # activity_as_tool runs the tool call as a real Temporal activity, so it's
         # retryable and shows up in history.
-        weather_tool = temporalio.contrib.google_adk_agents.workflow.activity_tool(
+        weather_tool = temporalio.contrib.google_adk_agents.workflow.activity_as_tool(
             get_weather, start_to_close_timeout=timedelta(seconds=60)
         )
 

lambda_worker/pyproject.toml

@@ -6,7 +6,7 @@ authors = [{ name = "Temporal Technologies Inc", email = "sdk@temporal.io" }]
 requires-python = ">=3.10"
 readme = "README.md"
 license = "MIT"
-dependencies = ["temporalio[lambda-worker-otel]>=1.26.0,<2"]
+dependencies = ["temporalio[lambda-worker-otel]>=1.32.0,<2"]
 
 [dependency-groups]
 dev = [

lambda_worker/uv.lock

@@ -0,0 +1,59 @@
+# Nexus operation backed by a standalone Activity
+
+This sample shows how to implement a `TemporalOperationHandler` that starts a
+standalone Activity as the backing execution for a Nexus operation. When the Activity
+finishes, Temporal delivers its result to the Nexus caller. The default handler
+cancellation implementation also forwards Nexus cancellation to the Activity.
+
+The APIs used by this sample are experimental and may change incompatibly.
+
+### Sample structure
+
+- [service.py](./service.py) defines the Nexus service shared by caller and handler.
+- [activity.py](./activity.py) defines the standalone Activity.
+- [handler.py](./handler.py) implements `TemporalOperationHandler.start_operation`.
+- [worker.py](./worker.py) hosts the Nexus handler and Activity.
+- [starter.py](./starter.py) executes the Nexus operation from client code.
+
+## Run locally
+
+This sample requires the [Temporal dev server build that supports standalone Nexus operations](https://docs.temporal.io/standalone-nexus-operation#temporal-cli-support) and Activity
+callbacks enabled.
+
+1. Start the server with caller and handler namespaces:
+
+   ```bash
+   ./temporal server start-dev \
+     --dynamic-config-value activity.enableCallbacks=true \
+     --namespace nexus-standalone-activity-caller \
+     --namespace nexus-standalone-activity-handler
+   ```
+
+2. Create an endpoint targeting the handler namespace and task queue:
+
+   ```bash
+   ./temporal operator nexus endpoint create \
+     --name nexus-standalone-activity-endpoint \
+     --target-namespace nexus-standalone-activity-handler \
+     --target-task-queue nexus-standalone-activity-handler
+   ```
+
+3. Start the handler Worker:
+
+   ```bash
+   TEMPORAL_NAMESPACE=nexus-standalone-activity-handler \
+     uv run nexus_standalone_activity/worker.py
+   ```
+
+4. Execute the operation from the caller namespace:
+
+   ```bash
+   TEMPORAL_NAMESPACE=nexus-standalone-activity-caller \
+     uv run nexus_standalone_activity/starter.py
+   ```
+
+Expected output:
+
+```text
+Hello, World!
+```

nexus_standalone_activity/README.md

@@ -0,0 +1 @@
+"""Nexus operation backed by a standalone Activity sample."""

nexus_standalone_activity/__init__.py

@@ -0,0 +1,10 @@
+"""Activity used as the backing execution for the Nexus operation."""
+
+from temporalio import activity
+
+from nexus_standalone_activity.service import GreetingInput, GreetingOutput
+
+
+@activity.defn
+async def create_greeting(input: GreetingInput) -> GreetingOutput:
+    return GreetingOutput(message=f"Hello, {input.name}!")

nexus_standalone_activity/activity.py

@@ -0,0 +1,36 @@
+"""Temporal operation handler that starts a standalone Activity."""
+
+from datetime import timedelta
+
+import nexusrpc.handler
+from temporalio import nexus
+
+from nexus_standalone_activity.activity import create_greeting
+from nexus_standalone_activity.service import (
+    GreetingInput,
+    GreetingOutput,
+    GreetingService,
+)
+
+
+def get_activity_id(input: GreetingInput) -> str:
+    return f"greeting-{input.name}"
+
+
+@nexusrpc.handler.service_handler(service=GreetingService)
+class GreetingServiceHandler:
+    @nexus.temporal_operation
+    async def greet(
+        self,
+        _ctx: nexus.TemporalStartOperationContext,
+        client: nexus.TemporalNexusClient,
+        input: GreetingInput,
+    ) -> nexus.TemporalOperationResult[GreetingOutput]:
+        # The standalone Activity becomes the asynchronous backing execution for
+        # this Nexus operation. Omitting task_queue uses the Nexus Worker's queue.
+        return await client.start_activity(
+            create_greeting,
+            input,
+            id=get_activity_id(input),
+            start_to_close_timeout=timedelta(seconds=10),
+        )