docs: tweak a few examples for stable runs

Author: seratch

examples/mcp/get_all_mcp_tools_example/main.py

@@ -60,12 +60,14 @@ async def resolve_interruptions(agent: Agent, result: Any) -> Any:
 async def main():
     current_dir = os.path.dirname(os.path.abspath(__file__))
     samples_dir = os.path.join(current_dir, "sample_files")
+    blocked_path = os.path.join(samples_dir, "test.txt")
 
     async with MCPServerStdio(
         name="Filesystem Server",
         params={
             "command": "npx",
             "args": ["-y", "@modelcontextprotocol/server-filesystem", samples_dir],
+            "cwd": samples_dir,
         },
         require_approval={"always": {"tool_names": ["read_text_file"]}},
     ) as server:
@@ -83,10 +85,16 @@ async def main():
             # Build an agent that uses the prefetched tools instead of mcp_servers.
             prefetched_agent = Agent(
                 name="Prefetched MCP Assistant",
-                instructions="Use the prefetched tools to help with file questions.",
+                instructions=(
+                    "Use the prefetched tools to help with file questions. "
+                    "When using path arguments, prefer absolute paths in the allowed directory."
+                ),
                 tools=all_tools,
             )
-            message = "List the available files and read one of them."
+            message = (
+                f"List files in this allowed directory: {samples_dir}. "
+                "Then read one of those files."
+            )
             print(f"\nRunning: {message}\n")
             result = await Runner.run(prefetched_agent, message)
             result = await resolve_interruptions(prefetched_agent, result)
@@ -105,10 +113,17 @@ async def main():
 
             filtered_agent = Agent(
                 name="Filtered MCP Assistant",
-                instructions="Use the filtered tools to respond.",
+                instructions=(
+                    "Use the filtered tools to respond. "
+                    "If a request requires a missing tool, explain that the capability is not "
+                    "available."
+                ),
                 tools=filtered_tools,
             )
-            blocked_message = "Create a file named sample_files/test.txt with the text hello."
+            blocked_message = (
+                f'Create a file named "{blocked_path}" with the text "hello". '
+                "If the available tools cannot create files, explain that clearly."
+            )
             print(f"\nRunning: {blocked_message}\n")
             filtered_result = await Runner.run(filtered_agent, blocked_message)
             filtered_result = await resolve_interruptions(filtered_agent, filtered_result)

examples/mcp/sse_example/server.py

@@ -1,6 +1,5 @@
 import random
 
-import requests
 from mcp.server.fastmcp import FastMCP
 
 # Create server
@@ -23,16 +22,16 @@ def get_secret_word() -> str:
 @mcp.tool()
 def get_current_weather(city: str) -> str:
     print(f"[debug-server] get_current_weather({city})")
-    # Avoid slow or flaky network calls during automated runs.
-    try:
-        endpoint = "https://wttr.in"
-        response = requests.get(f"{endpoint}/{city}", timeout=2)
-        if response.ok:
-            return response.text
-    except Exception:
-        pass
-    # Fallback keeps the tool responsive even when offline.
-    return f"Weather data unavailable right now; assume clear skies in {city}."
+    # Keep tool output deterministic so this example is stable in CI and offline environments.
+    weather_by_city = {
+        "tokyo": "sunny with a light breeze and 20°C",
+        "san francisco": "cool and foggy with 14°C",
+        "new york": "partly cloudy with 18°C",
+    }
+    forecast = weather_by_city.get(city.strip().lower())
+    if forecast:
+        return f"The weather in {city} is {forecast}."
+    return f"The weather data for {city} is unavailable in this demo."
 
 
 if __name__ == "__main__":

examples/mcp/tool_filter_example/main.py

@@ -24,12 +24,14 @@ async def run_with_auto_approval(agent: Agent[Any], message: str) -> str | None:
 async def main():
     current_dir = os.path.dirname(os.path.abspath(__file__))
     samples_dir = os.path.join(current_dir, "sample_files")
+    target_path = os.path.join(samples_dir, "test.txt")
 
     async with MCPServerStdio(
         name="Filesystem Server with filter",
         params={
             "command": "npx",
             "args": ["-y", "@modelcontextprotocol/server-filesystem", samples_dir],
+            "cwd": samples_dir,
         },
         require_approval="always",
         tool_filter=create_static_tool_filter(
@@ -39,19 +41,28 @@ async def main():
     ) as server:
         agent = Agent(
             name="MCP Assistant",
-            instructions="Use the filesystem tools to answer questions.",
+            instructions=(
+                "Use only the available filesystem tools. "
+                "All file paths should be absolute paths inside the allowed directory. "
+                "If a user asks for an action that requires an unavailable tool, "
+                "explicitly explain that it is blocked by the tool filter."
+            ),
             mcp_servers=[server],
         )
         trace_id = gen_trace_id()
         with trace(workflow_name="MCP Tool Filter Example", trace_id=trace_id):
             print(f"View trace: https://platform.openai.com/traces/trace?trace_id={trace_id}\n")
             result = await run_with_auto_approval(
-                agent, "List the files in the sample_files directory."
+                agent, f"List the files in this allowed directory: {samples_dir}"
             )
             print(result)
 
             blocked_result = await run_with_auto_approval(
-                agent, 'Create a file named sample_files/test.txt with the text "hello".'
+                agent,
+                (
+                    f'Create a file at "{target_path}" with the text "hello". '
+                    "If you cannot, explain that write operations are blocked by the tool filter."
+                ),
             )
             print("\nAttempting to write a file (should be blocked):")
             print(blocked_result)