docs(samples): Add ManagedAgent code-execution sample

Add a runnable sample under contributing/samples/managed_agent/code_execution
showing how to use ManagedAgent with the server-side code execution tool. Since
ManagedAgent has no code_executor field, code execution is enabled by passing the
raw types.Tool(code_execution=types.ToolCodeExecution()) config in tools. The
sample exposes a root_agent in agent.py and ships a README plus a matching
single-turn live integration test that verifies a code-executed prime-sum
computation.

Co-authored-by: Haran Rajkumar <haranrk@google.com>
PiperOrigin-RevId: 943548907

Author: haranrk

contributing/samples/managed_agent/code_execution/README.md

@@ -0,0 +1,54 @@
+# Managed Agent - Code Execution
+
+## Overview
+
+This sample runs a `ManagedAgent` configured with the built-in **code execution**
+tool so it can write and run code server-side to compute answers.
+
+Unlike a regular `LlmAgent` (which enables code execution via
+`code_executor=BuiltInCodeExecutor()`), `ManagedAgent` has no `code_executor`
+field. Instead you pass the raw built-in tool config
+`types.Tool(code_execution=types.ToolCodeExecution())` in `tools` -- the same
+config `BuiltInCodeExecutor` produces under the hood. This makes the sample a
+demonstration of the raw `types.Tool` server-side tool path.
+
+## Sample Inputs
+
+- `What is the sum of the first 50 prime numbers? Use code to compute it.`
+
+  The model writes and runs code server-side; the answer (5117) comes from the
+  executed code rather than the model guessing.
+
+- `Now do the same for the first 100 primes.`
+
+  A follow-up turn that reuses the recovered remote sandbox and the previous
+  interaction (answer: 24133), demonstrating multi-turn chaining.
+
+## Graph
+
+```mermaid
+graph LR
+    User -->|message| ManagedAgent
+    ManagedAgent -->|interactions.create| ManagedAgentsAPI
+    ManagedAgentsAPI -->|server-side code execution| ManagedAgentsAPI
+    ManagedAgentsAPI -->|streamed events| ManagedAgent
+    ManagedAgent -->|answer| User
+```
+
+## How To
+
+- **Create the agent**: instantiate `ManagedAgent` with an `agent_id`, an
+  `environment` spec, and
+  `tools=[types.Tool(code_execution=types.ToolCodeExecution())]`. No `model` is
+  set -- the model is part of the managed agent on the server.
+- **Enable code execution**: `ManagedAgent` has no `code_executor` field, so the
+  raw `types.Tool(code_execution=...)` config is passed in `tools`. The
+  interactions converter turns it into the server-side `code_execution` tool.
+- **Provision a sandbox**: `environment={'type': 'remote'}` requests a fresh
+  remote sandbox. The resulting environment id is stored on emitted events, so
+  subsequent turns automatically recover and reuse it.
+- **Multi-turn chaining**: the agent recovers the `previous_interaction_id` from
+  the session events, so follow-up turns continue the same interaction without
+  any extra wiring.
+- **Drive it**: a `ManagedAgent` is a `BaseAgent`, so a standard `Runner` runs
+  it just like any other agent.

contributing/samples/managed_agent/code_execution/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import agent

contributing/samples/managed_agent/code_execution/agent.py

@@ -0,0 +1,55 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A ManagedAgent that runs server-side code execution.
+
+``ManagedAgent`` calls the Managed Agents API directly from its run loop instead
+of running a local model loop. It currently supports server-side tools only.
+
+Unlike ``LlmAgent``, ``ManagedAgent`` has no ``code_executor`` field, so code
+execution is enabled by passing the raw built-in tool config
+``types.Tool(code_execution=types.ToolCodeExecution())`` in ``tools`` -- the
+same config ``BuiltInCodeExecutor`` produces under the hood. The model writes
+and runs code on the server to compute answers.
+
+A fresh remote sandbox is provisioned via ``environment={'type': 'remote'}``;
+the environment id is recovered from prior events so multi-turn conversations
+reuse the same sandbox.
+
+Run with ``adk web`` /
+``adk run contributing/samples/managed_agent/code_execution``. See the README
+for the required environment / auth setup.
+"""
+
+import os
+
+from google.adk.agents import ManagedAgent
+from google.genai import types
+
+# The Managed Agent id served by the Managed Agents API. Override with the
+# MANAGED_AGENT_ID environment variable if your project has access to a
+# different agent.
+_DEFAULT_AGENT_ID = 'antigravity-preview-05-2026'
+
+root_agent = ManagedAgent(
+    name='managed_code_execution_agent',
+    agent_id=os.environ.get('MANAGED_AGENT_ID', _DEFAULT_AGENT_ID),
+    # Provision a remote sandbox for the agent. The environment id is recovered
+    # from prior events, so follow-up turns reuse the same sandbox.
+    environment={'type': 'remote'},
+    # ManagedAgent has no `code_executor` field; enable server-side code
+    # execution by passing the raw built-in tool config. This is the same config
+    # BuiltInCodeExecutor appends for a regular LlmAgent.
+    tools=[types.Tool(code_execution=types.ToolCodeExecution())],
+)

tests/integration/test_managed_agent.py

@@ -86,3 +86,38 @@ async def test_google_search_project_hail_mary():
   assert (
       'james ortiz' in answer.lower()
   ), f'expected the grounded answer to contain "James Ortiz"; got: {answer!r}'
+
+
+@pytest.mark.asyncio
+async def test_code_execution_prime_sum():
+  agent = ManagedAgent(
+      name='managed_code_execution_agent',
+      agent_id=_AGENT_ID,
+      environment={'type': 'remote'},
+      tools=[types.Tool(code_execution=types.ToolCodeExecution())],
+  )
+  session_service = InMemorySessionService()
+  runner = Runner(
+      app_name='managed_agent_it',
+      agent=agent,
+      session_service=session_service,
+  )
+  session = await session_service.create_session(
+      app_name='managed_agent_it', user_id='test_user'
+  )
+
+  events = await _run_turn(
+      runner,
+      session,
+      'What is the sum of the first 50 prime numbers? Use code to compute it.',
+  )
+
+  answer = _joined_text(events)
+  print('\n=== ManagedAgent code execution answer ===\n', answer)
+  # The model may stream the number with thousands separators and/or stray
+  # whitespace (e.g. "5,117" or "5, 117"), so remove all whitespace and commas
+  # before matching the code-executed sum.
+  normalized = ''.join(answer.split()).replace(',', '')
+  assert (
+      '5117' in normalized
+  ), f'expected the code-executed sum 5117; got: {answer!r}'