docs(toolbox-adk): improve README with comprehensive usage examples

Author: anubhav756

packages/toolbox-adk/README.md

@@ -1,6 +1,10 @@
+![MCP Toolbox Logo](https://raw.githubusercontent.com/googleapis/genai-toolbox/main/logo.png)
+
 # Toolbox ADK Integration
 
-This package allows Google ADK agents to natively use tools from the MCP Toolbox.
+This package allows Google ADK (Agent Development Kit) agents to natively use tools from the [MCP Toolbox](https://github.com/googleapis/genai-toolbox).
+
+It provides a seamless bridge between the `toolbox-core` SDK and the ADK's `BaseTool` / `BaseToolset` interfaces, handling authentication propagation, header management, and tool wrapping automatically.
 
 ## Installation
 
@@ -10,18 +14,136 @@ pip install toolbox-adk
 
 ## Usage
 
+The primary entry point is the `ToolboxToolset`, which loads tools from a remote Toolbox server and adapts them for use with ADK agents.
+
 ```python
 from toolbox_adk import ToolboxToolset, CredentialStrategy
+from google.adk.agents import Agent
 
-# Configure auth (e.g., Use the agent's identity)
-creds = CredentialStrategy.toolbox_identity()
+# 1. Configure Authentication Strategy
+# Use the agent's own identity (Workload Identity)
+creds = CredentialStrategy.workload_identity(target_audience="https://my-toolbox-service-url")
+
+# 2. Create the Toolset
+toolset = ToolboxToolset(
+    server_url="https://my-toolbox-service-url",
+    toolset_name="my-toolset", # Optional: Load specific toolset
+    credentials=creds
+)
+
+# 3. Use in your ADK Agent
+agent = Agent(tools=toolset.get_tools())
+```
+
+## Authentication Strategies
+
+The `toolbox-adk` package provides flexible authentication strategies to handle `Client-to-Server` authentication (securing the connection to the Toolbox server) and `User Identity` propagation (authenticating the user for specific tools).
+
+Use the `CredentialStrategy` factory methods to create your configuration.
+
+### Workload Identity (Recommended for Cloud Run / GKE)
+
+Uses the agent's environment credentials (ADC) to generate an OIDC ID token. This is the standard way for one service to authenticate to another on Google Cloud.
+
+```python
+# target_audience should match the URL of your Toolbox server
+creds = CredentialStrategy.workload_identity(target_audience="https://my-toolbox-service.run.app")
 
-# Create the toolset
 toolset = ToolboxToolset(
-    server_url="http://localhost:5000",
+    server_url="https://my-toolbox-service.run.app",
     credentials=creds
 )
+```
+
+### User Identity (3-Legged OAuth)
+
+Propagates the end-user's identity to the Toolbox. This is used when the tools themselves need to act on behalf of the user (e.g., accessing the user's Drive or Calendar).
+
+```python
+creds = CredentialStrategy.user_identity(
+    client_id="YOUR_CLIENT_ID",
+    client_secret="YOUR_CLIENT_SECRET",
+    scopes=["https://www.googleapis.com/auth/drive"]
+)
+```
+
+### Manual Token (Development / Testing)
+
+Manually supply a token (e.g., a static API key or a temporary token).
+
+```python
+creds = CredentialStrategy.manual_token("my-secret-token")
+```
+
+### Toolbox Identity (No Auth)
+
+Use this if your Toolbox server does not require authentication (e.g., local development).
+
+```python
+creds = CredentialStrategy.toolbox_identity()
+```
+
+### Native ADK Integration
+
+If you are using ADK's configuration system (`AuthConfig` objects), you can create the strategy directly from it.
+
+```python
+# auth_config is an instance of google.adk.auth.auth_tool.AuthConfig
+creds = CredentialStrategy.from_adk_auth_config(auth_config)
+```
+
+## Advanced Configuration
+
+### Additional Headers
+
+You can inject custom headers into every request made to the Toolbox server. This is useful for passing tracing IDs, API keys, or other metadata.
+
+```python
+toolset = ToolboxToolset(
+    server_url="...",
+    additional_headers={
+        "X-Trace-ID": "12345",
+        "X-My-Header": lambda: get_dynamic_header_value() # Can be a callable
+    }
+)
+```
+
+### Global Parameter Binding
+
+Bind values to tool parameters globally across all loaded tools. These values will be fixed and hidden from the LLM.
 
-# Use in your agent
-# agent = Agent(tools=toolset.get_tools())
+```python
+toolset = ToolboxToolset(
+    server_url="...",
+    bound_params={
+        "region": "us-central1",
+        "api_key": lambda: get_api_key() # Can be a callable
+    }
+)
+```
+
+### Usage with Hooks
+
+You can attach `pre_hook` and `post_hook` functions to execute logic before and after every tool invocation.
+
+```python
+async def log_start(context):
+    print(f"Starting tool {context.tool_name}")
+
+async def log_end(context):
+    print(f"Finished tool {context.tool_name}")
+
+toolset = ToolboxToolset(
+    server_url="...",
+    pre_hook=log_start,
+    post_hook=log_end
+)
 ```
+
+## Contributing
+
+Contributions are welcome! Please refer to the `toolbox-core` [DEVELOPER.md](../toolbox-core/DEVELOPER.md) for general guidelines.
+
+## License
+
+This project is licensed under the Apache License 2.0.