diff --git a/src/core/tools/creative_formats.py b/src/core/tools/creative_formats.py
index ccb6b3284..cad59bca5 100644
--- a/src/core/tools/creative_formats.py
+++ b/src/core/tools/creative_formats.py
@@ -9,6 +9,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 
 logger = logging.getLogger(__name__)
@@ -120,20 +121,8 @@ def _list_creative_formats_impl(
     # Create response (no message/specification_version - not in adapter schema)
     response = ListCreativeFormatsResponse(formats=formats)
 
-    # Add schema validation metadata for client validation
-    from src.core.schema_validation import INCLUDE_SCHEMAS_IN_RESPONSES, enhance_mcp_response_with_schema
-
-    if INCLUDE_SCHEMAS_IN_RESPONSES:
-        # Convert to dict, enhance with schema, return enhanced dict
-        response_dict = response.model_dump()
-        enhanced_response = enhance_mcp_response_with_schema(
-            response_data=response_dict,
-            model_class=ListCreativeFormatsResponse,
-            include_full_schema=False,  # Set to True for development debugging
-        )
-        # Return the enhanced response (FastMCP handles dict returns)
-        return enhanced_response
-
+    # Always return Pydantic model - MCP wrapper will handle serialization
+    # Schema enhancement (if needed) should happen in the MCP wrapper, not here
     return response
 
 
@@ -144,7 +133,7 @@ def list_creative_formats(
     format_ids: list[str] | None = None,
     webhook_url: str | None = None,
     context: Context = None,
-) -> ListCreativeFormatsResponse:
+):
     """List all available creative formats (AdCP spec endpoint).
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -158,7 +147,7 @@ def list_creative_formats(
         context: FastMCP context (automatically provided)
 
     Returns:
-        ListCreativeFormatsResponse with all available formats
+        ToolResult with ListCreativeFormatsResponse data
     """
     try:
         req = ListCreativeFormatsRequest(
@@ -170,7 +159,8 @@ def list_creative_formats(
     except ValidationError as e:
         raise ToolError(format_validation_error(e, context="list_creative_formats request")) from e
 
-    return _list_creative_formats_impl(req, context)
+    response = _list_creative_formats_impl(req, context)
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def list_creative_formats_raw(
diff --git a/src/core/tools/creatives.py b/src/core/tools/creatives.py
index e235e3cc4..2a712b430 100644
--- a/src/core/tools/creatives.py
+++ b/src/core/tools/creatives.py
@@ -14,6 +14,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 from rich.console import Console
 from sqlalchemy import select
@@ -1424,7 +1425,7 @@ def sync_creatives(
     validation_mode: str = "strict",
     push_notification_config: dict | None = None,
     context: Context | None = None,
-) -> SyncCreativesResponse:
+):
     """Sync creative assets to centralized library (AdCP v2.4 spec compliant endpoint).
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -1440,9 +1441,9 @@ def sync_creatives(
         context: FastMCP context (automatically provided)
 
     Returns:
-        SyncCreativesResponse with sync results
+        ToolResult with SyncCreativesResponse data
     """
-    return _sync_creatives_impl(
+    response = _sync_creatives_impl(
         creatives=creatives,
         patch=patch,
         assignments=assignments,
@@ -1452,6 +1453,7 @@ def sync_creatives(
         push_notification_config=push_notification_config,
         context=context,
     )
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def _list_creatives_impl(
@@ -1777,14 +1779,17 @@ def list_creatives(
     sort_order: str = "desc",
     webhook_url: str | None = None,
     context: Context = None,
-) -> ListCreativesResponse:
+):
     """List and filter creative assets from the centralized library.
 
     MCP tool wrapper that delegates to the shared implementation.
     Supports both flat parameters (status, format, etc.) and nested objects (filters, sort, pagination)
     for maximum flexibility.
+
+    Returns:
+        ToolResult with ListCreativesResponse data
     """
-    return _list_creatives_impl(
+    response = _list_creatives_impl(
         media_buy_id,
         buyer_ref,
         status,
@@ -1806,6 +1811,7 @@ def list_creatives(
         sort_order,
         context,
     )
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def sync_creatives_raw(
diff --git a/src/core/tools/media_buy_create.py b/src/core/tools/media_buy_create.py
index c1ad047bc..cd92f5afd 100644
--- a/src/core/tools/media_buy_create.py
+++ b/src/core/tools/media_buy_create.py
@@ -16,6 +16,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 from rich.console import Console
 
@@ -1889,7 +1890,7 @@ async def create_media_buy(
     push_notification_config: dict[str, Any] | None = None,
     webhook_url: str | None = None,
     context: Context | None = None,
-) -> CreateMediaBuyResponse:
+):
     """Create a media buy with the specified parameters.
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -1918,9 +1919,9 @@ async def create_media_buy(
         context: FastMCP context (automatically provided)
 
     Returns:
-        CreateMediaBuyResponse with media buy details
+        ToolResult with CreateMediaBuyResponse data
     """
-    return await _create_media_buy_impl(
+    response = await _create_media_buy_impl(
         buyer_ref=buyer_ref,
         brand_manifest=brand_manifest,
         po_number=po_number,
@@ -1943,6 +1944,7 @@ async def create_media_buy(
         push_notification_config=push_notification_config,
         context=context,
     )
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 async def create_media_buy_raw(
diff --git a/src/core/tools/media_buy_delivery.py b/src/core/tools/media_buy_delivery.py
index 384248dbb..d45811321 100644
--- a/src/core/tools/media_buy_delivery.py
+++ b/src/core/tools/media_buy_delivery.py
@@ -13,6 +13,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 from rich.console import Console
 
@@ -310,7 +311,7 @@ def get_media_buy_delivery(
     end_date: str = None,
     webhook_url: str | None = None,
     context: Context = None,
-) -> GetMediaBuyDeliveryResponse:
+):
     """Get delivery data for media buys.
 
     AdCP-compliant implementation of get_media_buy_delivery tool.
@@ -325,7 +326,7 @@ def get_media_buy_delivery(
         context: FastMCP context (automatically provided)
 
     Returns:
-        GetMediaBuyDeliveryResponse with AdCP-compliant delivery data for the requested media buys
+        ToolResult with GetMediaBuyDeliveryResponse data
     """
     # Create AdCP-compliant request object
     try:
@@ -339,7 +340,8 @@ def get_media_buy_delivery(
     except ValidationError as e:
         raise ToolError(format_validation_error(e, context="get_media_buy_delivery request")) from e
 
-    return _get_media_buy_delivery_impl(req, context)
+    response = _get_media_buy_delivery_impl(req, context)
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def get_media_buy_delivery_raw(
diff --git a/src/core/tools/media_buy_update.py b/src/core/tools/media_buy_update.py
index 298989be8..48fa3567b 100644
--- a/src/core/tools/media_buy_update.py
+++ b/src/core/tools/media_buy_update.py
@@ -13,6 +13,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 from sqlalchemy import select
 
@@ -663,7 +664,7 @@ def update_media_buy(
     creatives: list = None,
     push_notification_config: dict | None = None,
     context: Context = None,
-) -> UpdateMediaBuyResponse:
+):
     """Update a media buy with campaign-level and/or package-level changes.
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -687,9 +688,9 @@ def update_media_buy(
         context: FastMCP context (automatically provided)
 
     Returns:
-        UpdateMediaBuyResponse with updated media buy details
+        ToolResult with UpdateMediaBuyResponse data
     """
-    return _update_media_buy_impl(
+    response = _update_media_buy_impl(
         media_buy_id=media_buy_id,
         buyer_ref=buyer_ref,
         active=active,
@@ -707,6 +708,7 @@ def update_media_buy(
         push_notification_config=push_notification_config,
         context=context,
     )
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def update_media_buy_raw(
diff --git a/src/core/tools/performance.py b/src/core/tools/performance.py
index 6554826c7..7a6da9c37 100644
--- a/src/core/tools/performance.py
+++ b/src/core/tools/performance.py
@@ -9,6 +9,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 from rich.console import Console
 
@@ -23,19 +24,18 @@
 from src.core.validation_helpers import format_validation_error
 
 
-def update_performance_index(
-    media_buy_id: str, performance_data: list[dict[str, Any]], webhook_url: str | None = None, context: Context = None
+def _update_performance_index_impl(
+    media_buy_id: str, performance_data: list[dict[str, Any]], context: Context = None
 ) -> UpdatePerformanceIndexResponse:
-    """Update performance index data for a media buy.
+    """Shared implementation for update_performance_index (used by both MCP and A2A).
 
     Args:
         media_buy_id: ID of the media buy to update
         performance_data: List of performance data objects
-        webhook_url: URL for async task completion notifications (AdCP spec, optional)
         context: FastMCP context (automatically provided)
 
     Returns:
-        UpdatePerformanceIndexResponse with operation status
+        UpdatePerformanceIndexResponse with update status
     """
     # Create request object from individual parameters (MCP-compliant)
     # Convert dict performance_data to ProductPerformance objects
@@ -92,6 +92,26 @@ def update_performance_index(
     )
 
 
+def update_performance_index(
+    media_buy_id: str, performance_data: list[dict[str, Any]], webhook_url: str | None = None, context: Context = None
+):
+    """Update performance index data for a media buy.
+
+    MCP tool wrapper that delegates to the shared implementation.
+
+    Args:
+        media_buy_id: ID of the media buy to update
+        performance_data: List of performance data objects
+        webhook_url: URL for async task completion notifications (AdCP spec, optional)
+        context: FastMCP context (automatically provided)
+
+    Returns:
+        ToolResult with UpdatePerformanceIndexResponse data
+    """
+    response = _update_performance_index_impl(media_buy_id, performance_data, context)
+    return ToolResult(content=str(response), structured_content=response.model_dump())
+
+
 def update_performance_index_raw(media_buy_id: str, performance_data: list[dict[str, Any]], context: Context = None):
     """Update performance data for a media buy (raw function for A2A server use).
 
@@ -105,7 +125,7 @@ def update_performance_index_raw(media_buy_id: str, performance_data: list[dict[
     Returns:
         UpdatePerformanceIndexResponse
     """
-    return update_performance_index(media_buy_id, performance_data, webhook_url=None, context=context)
+    return _update_performance_index_impl(media_buy_id, performance_data, context)
 
 
 # --- Human-in-the-Loop Task Queue Tools ---
diff --git a/src/core/tools/products.py b/src/core/tools/products.py
index 437668cb3..85129b936 100644
--- a/src/core/tools/products.py
+++ b/src/core/tools/products.py
@@ -12,6 +12,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from pydantic import ValidationError
 
 # Imports for implementation
@@ -505,7 +506,7 @@ async def get_products(
     brief: str = "",
     filters: dict | None = None,
     context: Context = None,
-) -> GetProductsResponse:
+):
     """Get available products matching the brief.
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -517,7 +518,7 @@ async def get_products(
         context: FastMCP context (automatically provided)
 
     Returns:
-        GetProductsResponse containing matching products
+        ToolResult with human-readable text and structured data
 
     Note:
         promoted_offering is deprecated - use brand_manifest instead.
@@ -539,7 +540,10 @@ async def get_products(
 
     # Call shared implementation
     # Note: GetProductsRequest is now a flat class (not RootModel), so pass req directly
-    return await _get_products_impl(req, context)
+    response = await _get_products_impl(req, context)
+
+    # Return ToolResult with human-readable text and structured data
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 async def get_products_raw(
diff --git a/src/core/tools/properties.py b/src/core/tools/properties.py
index b8334e5b5..3ee9a457a 100644
--- a/src/core/tools/properties.py
+++ b/src/core/tools/properties.py
@@ -13,6 +13,7 @@
 import sqlalchemy as sa
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 from sqlalchemy import select
 
 logger = logging.getLogger(__name__)
@@ -243,7 +244,7 @@ def _list_authorized_properties_impl(
 
 def list_authorized_properties(
     req: ListAuthorizedPropertiesRequest | None = None, webhook_url: str | None = None, context: Context | None = None
-) -> ListAuthorizedPropertiesResponse:
+):
     """List all properties this agent is authorized to represent (AdCP spec endpoint).
 
     MCP tool wrapper that delegates to the shared implementation.
@@ -254,7 +255,7 @@ def list_authorized_properties(
         context: FastMCP context for authentication
 
     Returns:
-        ListAuthorizedPropertiesResponse with properties and tag metadata
+        ToolResult with human-readable text and structured data
     """
     # FIX: Create MinimalContext with headers from FastMCP request (like A2A does)
     # This ensures tenant detection works the same way for both MCP and A2A
@@ -309,7 +310,12 @@ def __init__(self, headers):
         logger.info("MCP list_authorized_properties: No context provided")
         tool_context = context
 
-    return _list_authorized_properties_impl(req, tool_context)
+    response = _list_authorized_properties_impl(req, tool_context)
+
+    # Return ToolResult with human-readable text and structured data
+    # The __str__() method provides the human-readable message
+    # The model_dump() provides the structured JSON data
+    return ToolResult(content=str(response), structured_content=response.model_dump())
 
 
 def list_authorized_properties_raw(
diff --git a/src/core/tools/signals.py b/src/core/tools/signals.py
index ffabd7a71..3daac8a3f 100644
--- a/src/core/tools/signals.py
+++ b/src/core/tools/signals.py
@@ -10,6 +10,7 @@
 
 from fastmcp.exceptions import ToolError
 from fastmcp.server.context import Context
+from fastmcp.tools.tool import ToolResult
 
 logger = logging.getLogger(__name__)
 
@@ -28,17 +29,16 @@ def _get_principal_id_from_context(context: Context | None) -> str | None:
     return principal_id
 
 
-async def get_signals(req: GetSignalsRequest, context: Context = None) -> GetSignalsResponse:
-    """Optional endpoint for discovering available signals (audiences, contextual, etc.)
+async def _get_signals_impl(req: GetSignalsRequest, context: Context = None) -> GetSignalsResponse:
+    """Shared implementation for get_signals (used by both MCP and A2A).
 
     Args:
         req: Request containing query parameters for signal discovery
         context: FastMCP context (automatically provided)
 
     Returns:
-        GetSignalsResponse containing matching signals
+        GetSignalsResponse with matching signals
     """
-
     _get_principal_id_from_context(context)
 
     # Get tenant information
@@ -188,13 +188,29 @@ async def get_signals(req: GetSignalsRequest, context: Context = None) -> GetSig
     return GetSignalsResponse(signals=signals)
 
 
-async def activate_signal(
+async def get_signals(req: GetSignalsRequest, context: Context = None):
+    """Optional endpoint for discovering available signals (audiences, contextual, etc.)
+
+    MCP tool wrapper that delegates to the shared implementation.
+
+    Args:
+        req: Request containing query parameters for signal discovery
+        context: FastMCP context (automatically provided)
+
+    Returns:
+        ToolResult with GetSignalsResponse data
+    """
+    response = await _get_signals_impl(req, context)
+    return ToolResult(content=str(response), structured_content=response.model_dump())
+
+
+async def _activate_signal_impl(
     signal_id: str,
     campaign_id: str = None,
     media_buy_id: str = None,
     context: Context = None,
 ) -> ActivateSignalResponse:
-    """Activate a signal for use in campaigns.
+    """Shared implementation for activate_signal (used by both MCP and A2A).
 
     Args:
         signal_id: Signal ID to activate
@@ -259,13 +275,13 @@ async def activate_signal(
 
         # Build response with adapter schema fields
         if requires_approval or not activation_success:
-            return ActivateSignalResponse(
+            response = ActivateSignalResponse(
                 task_id=task_id,
                 status=status,
                 errors=errors,
             )
         else:
-            return ActivateSignalResponse(
+            response = ActivateSignalResponse(
                 task_id=task_id,
                 status=status,
                 decisioning_platform_segment_id=decisioning_platform_segment_id if activation_success else None,
@@ -273,6 +289,7 @@ async def activate_signal(
                     estimated_activation_duration_minutes if activation_success else None
                 ),
             )
+        return response
 
     except Exception as e:
         logger.error(f"Error activating signal {signal_id}: {e}")
@@ -283,6 +300,29 @@ async def activate_signal(
         )
 
 
+async def activate_signal(
+    signal_id: str,
+    campaign_id: str = None,
+    media_buy_id: str = None,
+    context: Context = None,
+):
+    """Activate a signal for use in campaigns.
+
+    MCP tool wrapper that delegates to the shared implementation.
+
+    Args:
+        signal_id: Signal ID to activate
+        campaign_id: Optional campaign ID to activate signal for
+        media_buy_id: Optional media buy ID to activate signal for
+        context: FastMCP context (automatically provided)
+
+    Returns:
+        ToolResult with ActivateSignalResponse data
+    """
+    response = await _activate_signal_impl(signal_id, campaign_id, media_buy_id, context)
+    return ToolResult(content=str(response), structured_content=response.model_dump())
+
+
 async def get_signals_raw(req: GetSignalsRequest, context: Context = None) -> GetSignalsResponse:
     """Optional endpoint for discovering available signals (raw function for A2A server use).
 
@@ -295,4 +335,26 @@ async def get_signals_raw(req: GetSignalsRequest, context: Context = None) -> Ge
     Returns:
         GetSignalsResponse containing matching signals
     """
-    return await get_signals(req, context)
+    return await _get_signals_impl(req, context)
+
+
+async def activate_signal_raw(
+    signal_id: str,
+    campaign_id: str = None,
+    media_buy_id: str = None,
+    context: Context = None,
+) -> ActivateSignalResponse:
+    """Activate a signal for use in campaigns (raw function for A2A server use).
+
+    Delegates to the shared implementation.
+
+    Args:
+        signal_id: Signal ID to activate
+        campaign_id: Optional campaign ID to activate signal for
+        media_buy_id: Optional media buy ID to activate signal for
+        context: Context for authentication
+
+    Returns:
+        ActivateSignalResponse with activation status
+    """
+    return await _activate_signal_impl(signal_id, campaign_id, media_buy_id, context)
diff --git a/tests/e2e/adcp_request_builder.py b/tests/e2e/adcp_request_builder.py
index ca92356ea..d3da5dc81 100644
--- a/tests/e2e/adcp_request_builder.py
+++ b/tests/e2e/adcp_request_builder.py
@@ -15,6 +15,33 @@ def generate_buyer_ref(prefix: str = "test") -> str:
     return f"{prefix}_{uuid.uuid4().hex[:8]}"
 
 
+def parse_tool_result(result: Any) -> dict[str, Any]:
+    """
+    Parse MCP tool result into structured data.
+
+    Extracts structured data from ToolResult.structured_content field.
+    The text field contains human-readable text, structured_content has the JSON data.
+
+    Args:
+        result: MCP tool result object with structured_content
+
+    Returns:
+        Parsed result data as a dictionary
+
+    Example:
+        >>> products_result = await client.call_tool("get_products", {...})
+        >>> products_data = parse_tool_result(products_result)
+        >>> assert "products" in products_data
+    """
+    if hasattr(result, "structured_content") and result.structured_content:
+        return result.structured_content
+
+    raise ValueError(
+        f"Unable to parse tool result: {type(result).__name__} has no structured_content field. "
+        f"Expected ToolResult with structured_content."
+    )
+
+
 def build_adcp_media_buy_request(
     product_ids: list[str],
     total_budget: float,
diff --git a/tests/e2e/test_adcp_reference_implementation.py b/tests/e2e/test_adcp_reference_implementation.py
index 30f5463ab..9b28e14d3 100644
--- a/tests/e2e/test_adcp_reference_implementation.py
+++ b/tests/e2e/test_adcp_reference_implementation.py
@@ -27,6 +27,7 @@
     build_creative,
     build_sync_creatives_request,
     get_test_date_range,
+    parse_tool_result,
 )
 
 
@@ -131,7 +132,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
                     "brief": "display advertising",
                 },
             )
-            products_data = json.loads(products_result.content[0].text)
+            products_data = parse_tool_result(products_result)
 
             print(f"   🔍 DEBUG: products_result type: {type(products_result)}")
             print(f"   🔍 DEBUG: products_result.content: {products_result.content}")
@@ -145,11 +146,12 @@ async def test_complete_campaign_lifecycle_with_webhooks(
             product = products_data["products"][0]
             product_id = product["product_id"]
             print(f"   ✓ Found product: {product['name']} ({product_id})")
-            print(f"   ✓ Formats: {product['format_ids']}")
+            # AdCP spec uses 'formats' not 'format_ids'
+            print(f"   ✓ Formats: {product['formats']}")
 
             # Get creative formats (no req wrapper - takes optional params directly)
             formats_result = await client.call_tool("list_creative_formats", {})
-            formats_data = json.loads(formats_result.content[0].text)
+            formats_data = parse_tool_result(formats_result)
 
             assert "formats" in formats_data, "Response must contain formats"
             print(f"   ✓ Available formats: {len(formats_data['formats'])}")
@@ -177,7 +179,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
 
             # Create media buy (pass params directly - no req wrapper)
             media_buy_result = await client.call_tool("create_media_buy", media_buy_request)
-            media_buy_data = json.loads(media_buy_result.content[0].text)
+            media_buy_data = parse_tool_result(media_buy_result)
 
             # When webhook is provided, response may have task_id instead of media_buy_id
             # For this test, we'll use buyer_ref if media_buy_id is not available
@@ -226,7 +228,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
             sync_request = build_sync_creatives_request(creatives=[creative_1, creative_2])
 
             sync_result = await client.call_tool("sync_creatives", sync_request)
-            sync_data = json.loads(sync_result.content[0].text)
+            sync_data = parse_tool_result(sync_result)
 
             assert "results" in sync_data, "Response must contain results"
             assert len(sync_data["results"]) == 2, "Should sync 2 creatives"
@@ -239,7 +241,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
             print("\n📊 PHASE 4: Get Delivery Metrics")
 
             delivery_result = await client.call_tool("get_media_buy_delivery", {"media_buy_ids": [media_buy_id]})
-            delivery_data = json.loads(delivery_result.content[0].text)
+            delivery_data = parse_tool_result(delivery_result)
 
             # Verify delivery response structure (AdCP spec: deliveries is an array)
             assert "deliveries" in delivery_data or "media_buy_deliveries" in delivery_data
@@ -273,7 +275,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
                     },
                 },
             )
-            update_data = json.loads(update_result.content[0].text)
+            update_data = parse_tool_result(update_result)
 
             assert "media_buy_id" in update_data or "buyer_ref" in update_data
             print("   ✓ Budget update requested: $5000 → $7500")
@@ -318,7 +320,7 @@ async def test_complete_campaign_lifecycle_with_webhooks(
             print("\n📋 PHASE 7: List Creatives (verify final state)")
 
             list_result = await client.call_tool("list_creatives", {})
-            list_data = json.loads(list_result.content[0].text)
+            list_data = parse_tool_result(list_result)
 
             assert "creatives" in list_data, "Response must contain creatives"
             print(f"   ✓ Listed {len(list_data['creatives'])} creatives")
diff --git a/tests/e2e/test_creative_assignment_e2e.py b/tests/e2e/test_creative_assignment_e2e.py
index a51b0ad85..8f4a99bbc 100644
--- a/tests/e2e/test_creative_assignment_e2e.py
+++ b/tests/e2e/test_creative_assignment_e2e.py
@@ -19,6 +19,7 @@
     build_creative,
     build_sync_creatives_request,
     get_test_date_range,
+    parse_tool_result,
 )
 
 
@@ -65,7 +66,7 @@ async def test_creative_sync_with_assignment_in_single_call(
                     "brief": "display advertising",
                 },
             )
-            products_data = json.loads(products_result.content[0].text)
+            products_data = parse_tool_result(products_result)
 
             assert "products" in products_data, "Response must contain products"
             assert len(products_data["products"]) > 0, "Must have at least one product"
@@ -76,7 +77,7 @@ async def test_creative_sync_with_assignment_in_single_call(
 
             # Get creative formats
             formats_result = await client.call_tool("list_creative_formats", {})
-            formats_data = json.loads(formats_result.content[0].text)
+            formats_data = parse_tool_result(formats_result)
 
             assert "formats" in formats_data, "Response must contain formats"
             print(f"   ✓ Available formats: {len(formats_data['formats'])}")
@@ -121,7 +122,7 @@ async def test_creative_sync_with_assignment_in_single_call(
             media_buy_request["packages"][0]["buyer_ref"] = package_buyer_ref
 
             media_buy_result = await client.call_tool("create_media_buy", media_buy_request)
-            media_buy_data = json.loads(media_buy_result.content[0].text)
+            media_buy_data = parse_tool_result(media_buy_result)
 
             media_buy_id = media_buy_data.get("media_buy_id")
             buyer_ref = media_buy_data.get("buyer_ref")
@@ -167,7 +168,7 @@ async def test_creative_sync_with_assignment_in_single_call(
             print(f"   📋 Sync request: {json.dumps(sync_request, indent=2)}")
 
             sync_result = await client.call_tool("sync_creatives", sync_request)
-            sync_data = json.loads(sync_result.content[0].text)
+            sync_data = parse_tool_result(sync_result)
 
             print(f"   📋 Sync response: {json.dumps(sync_data, indent=2)}")
 
@@ -184,7 +185,7 @@ async def test_creative_sync_with_assignment_in_single_call(
             print("\n📊 PHASE 4: Verify Assignment via Get Delivery")
 
             delivery_result = await client.call_tool("get_media_buy_delivery", {"media_buy_ids": [media_buy_id]})
-            delivery_data = json.loads(delivery_result.content[0].text)
+            delivery_data = parse_tool_result(delivery_result)
 
             print(f"   📋 Delivery response: {json.dumps(delivery_data, indent=2)[:1000]}")
 
@@ -213,7 +214,7 @@ async def test_creative_sync_with_assignment_in_single_call(
             print("\n📋 PHASE 5: List Creatives (verify final state)")
 
             list_result = await client.call_tool("list_creatives", {})
-            list_data = json.loads(list_result.content[0].text)
+            list_data = parse_tool_result(list_result)
 
             assert "creatives" in list_data, "Response must contain creatives"
             print(f"   ✓ Listed {len(list_data['creatives'])} creatives")
@@ -274,7 +275,7 @@ async def test_multiple_creatives_multiple_packages(self, docker_services_e2e, l
                     "brief": "display advertising",
                 },
             )
-            products_data = json.loads(products_result.content[0].text)
+            products_data = parse_tool_result(products_result)
 
             assert len(products_data["products"]) > 0, "Must have at least one product"
             product = products_data["products"][0]
@@ -283,7 +284,7 @@ async def test_multiple_creatives_multiple_packages(self, docker_services_e2e, l
 
             # Get formats
             formats_result = await client.call_tool("list_creative_formats", {})
-            formats_data = json.loads(formats_result.content[0].text)
+            formats_data = parse_tool_result(formats_result)
 
             format_id = None
             for fmt in formats_data["formats"]:
@@ -334,7 +335,7 @@ async def test_multiple_creatives_multiple_packages(self, docker_services_e2e, l
             ]
 
             media_buy_result = await client.call_tool("create_media_buy", media_buy_request)
-            media_buy_data = json.loads(media_buy_result.content[0].text)
+            media_buy_data = parse_tool_result(media_buy_result)
 
             media_buy_id = media_buy_data.get("media_buy_id")
 
@@ -399,7 +400,7 @@ async def test_multiple_creatives_multiple_packages(self, docker_services_e2e, l
             )
 
             sync_result = await client.call_tool("sync_creatives", sync_request)
-            sync_data = json.loads(sync_result.content[0].text)
+            sync_data = parse_tool_result(sync_result)
 
             assert "results" in sync_data, "Response must contain results"
             assert len(sync_data["results"]) == 3, "Should sync 3 creatives"
@@ -411,7 +412,7 @@ async def test_multiple_creatives_multiple_packages(self, docker_services_e2e, l
             print("\n📊 PHASE 4: Verify Assignments")
 
             delivery_result = await client.call_tool("get_media_buy_delivery", {"media_buy_ids": [media_buy_id]})
-            delivery_data = json.loads(delivery_result.content[0].text)
+            delivery_data = parse_tool_result(delivery_result)
 
             deliveries = delivery_data.get("deliveries") or delivery_data.get("media_buy_deliveries", [])
             if deliveries and "packages" in deliveries[0]:
diff --git a/tests/integration/test_generative_creatives.py b/tests/integration/test_generative_creatives.py
index 0ca03c3c4..d0cf9580a 100644
--- a/tests/integration/test_generative_creatives.py
+++ b/tests/integration/test_generative_creatives.py
@@ -32,10 +32,9 @@ class TestGenerativeCreatives:
 
     def _import_sync_creatives(self):
         """Import sync_creatives MCP tool."""
-        from src.core.main import sync_creatives as core_sync_creatives_tool
+        from src.core.tools.creatives import sync_creatives_raw
 
-        sync_fn = core_sync_creatives_tool.fn if hasattr(core_sync_creatives_tool, "fn") else core_sync_creatives_tool
-        return sync_fn
+        return sync_creatives_raw
 
     @pytest.fixture(autouse=True)
     def setup_test_data(self, integration_db):
diff --git a/tests/integration/test_list_creatives_auth.py b/tests/integration/test_list_creatives_auth.py
index 0b52edfd9..e97374188 100644
--- a/tests/integration/test_list_creatives_auth.py
+++ b/tests/integration/test_list_creatives_auth.py
@@ -117,11 +117,9 @@ def setup_test_data(self, integration_db):
 
     def _import_mcp_tool(self):
         """Import MCP tool to avoid module-level database initialization."""
-        from src.core.main import list_creatives as core_list_creatives_tool
+        from src.core.tools.creatives import list_creatives_raw
 
-        # Extract the actual function from FunctionTool object if needed
-        list_fn = core_list_creatives_tool.fn if hasattr(core_list_creatives_tool, "fn") else core_list_creatives_tool
-        return list_fn
+        return list_creatives_raw
 
     def test_unauthenticated_request_should_fail(self):
         """Test that list_creatives rejects requests without authentication.
diff --git a/tests/integration_v2/test_creative_lifecycle_mcp.py b/tests/integration_v2/test_creative_lifecycle_mcp.py
index 467bf149f..c737f3c23 100644
--- a/tests/integration_v2/test_creative_lifecycle_mcp.py
+++ b/tests/integration_v2/test_creative_lifecycle_mcp.py
@@ -48,14 +48,9 @@ class TestCreativeLifecycleMCP:
 
     def _import_mcp_tools(self):
         """Import MCP tools to avoid module-level database initialization."""
-        from src.core.main import list_creatives as core_list_creatives_tool
-        from src.core.main import sync_creatives as core_sync_creatives_tool
+        from src.core.tools.creatives import list_creatives_raw, sync_creatives_raw
 
-        # Extract the actual functions from FunctionTool objects if needed
-        sync_fn = core_sync_creatives_tool.fn if hasattr(core_sync_creatives_tool, "fn") else core_sync_creatives_tool
-        list_fn = core_list_creatives_tool.fn if hasattr(core_list_creatives_tool, "fn") else core_list_creatives_tool
-
-        return sync_fn, list_fn
+        return sync_creatives_raw, list_creatives_raw
 
     @pytest.fixture(autouse=True)
     def setup_test_data(self, integration_db):
diff --git a/tests/integration_v2/test_get_products_filters.py b/tests/integration_v2/test_get_products_filters.py
index 5a94c3bc9..8a1886011 100644
--- a/tests/integration_v2/test_get_products_filters.py
+++ b/tests/integration_v2/test_get_products_filters.py
@@ -53,11 +53,9 @@ class TestGetProductsFilterBehavior:
 
     def _import_get_products_tool(self):
         """Import get_products tool and extract underlying function."""
-        from src.core.main import get_products as core_get_products_tool
+        from src.core.tools.products import get_products_raw
 
-        # Extract the actual function from FunctionTool object if needed
-        get_products_fn = core_get_products_tool.fn if hasattr(core_get_products_tool, "fn") else core_get_products_tool
-        return get_products_fn
+        return get_products_raw
 
     @pytest.fixture(autouse=True)
     def setup_diverse_products(self, integration_db):
diff --git a/tests/integration_v2/test_mcp_endpoints_comprehensive.py b/tests/integration_v2/test_mcp_endpoints_comprehensive.py
index b33820a84..5a99785e7 100644
--- a/tests/integration_v2/test_mcp_endpoints_comprehensive.py
+++ b/tests/integration_v2/test_mcp_endpoints_comprehensive.py
@@ -164,7 +164,8 @@ async def test_get_products_basic(self, mcp_client):
                 assert "product_id" in product
                 assert "name" in product
                 assert "description" in product
-                assert "format_ids" in product
+                # AdCP spec uses "formats" (array of FormatId objects), not "format_ids"
+                assert "formats" in product
                 assert "delivery_type" in product
                 assert product["delivery_type"] in ["guaranteed", "non_guaranteed"]
                 # Pricing options should be included
@@ -381,9 +382,10 @@ async def test_full_workflow(self, mcp_client):
             assert "media_buy_deliveries" in status_content
             # Newly created media buy might not have delivery data yet
             assert isinstance(status_content["media_buy_deliveries"], list)
-            # But should have aggregated totals
-            assert "aggregated_totals" in status_content
+            # Currency is required per AdCP spec
             assert "currency" in status_content
+            # aggregated_totals is optional per AdCP spec (only for API responses, not webhooks)
+            # Don't assert it must exist
 
 
 if __name__ == "__main__":
diff --git a/tests/integration_v2/test_signals_agent_workflow.py b/tests/integration_v2/test_signals_agent_workflow.py
index 67f1e48de..ec12ef77a 100644
--- a/tests/integration_v2/test_signals_agent_workflow.py
+++ b/tests/integration_v2/test_signals_agent_workflow.py
@@ -14,7 +14,7 @@
 from src.core.database.database_session import get_db_session
 from src.core.database.models import Tenant
 from src.core.schemas import Signal
-from src.core.tools.products import get_products
+from src.core.tools.products import get_products_raw
 from tests.fixtures.builders import create_test_tenant_with_principal
 from tests.integration_v2.conftest import create_test_product_with_pricing
 
@@ -129,7 +129,7 @@ async def test_get_products_without_signals_config(self, tenant_without_signals_
         # Use single context patch with real tenant data
         with self._mock_auth_context(tenant_data):
             # Call get_products with correct parameters (not GetProductsRequest object)
-            response = await get_products(
+            response = await get_products_raw(
                 brand_manifest={"name": "BMW M3 2025 sports sedan"},
                 brief="sports car advertising campaign",
                 filters=None,
@@ -165,7 +165,7 @@ async def test_get_products_with_signals_success(
 
             with self._mock_auth_context(tenant_data):
                 # Call get_products with correct parameters
-                response = await get_products(
+                response = await get_products_raw(
                     brand_manifest={"name": "Porsche 911 Turbo S 2025"},
                     brief="luxury sports car advertising for wealthy professionals",
                     filters=None,
@@ -202,7 +202,7 @@ async def test_get_products_signals_upstream_failure_fallback(
 
             with self._mock_auth_context(tenant_data):
                 # Call get_products with correct parameters
-                response = await get_products(
+                response = await get_products_raw(
                     brand_manifest={"name": "Test Product 2025"},
                     brief="test brief for failure scenario",
                     filters=None,
@@ -234,7 +234,7 @@ async def test_get_products_no_brief_optimization(self, tenant_with_signals_conf
 
             with self._mock_auth_context(tenant_data):
                 # Call get_products with correct parameters (empty brief)
-                response = await get_products(
+                response = await get_products_raw(
                     brand_manifest={"name": "Generic Product 2025"},
                     brief="",
                     filters=None,
diff --git a/tests/integration_v2/test_tool_result_format.py b/tests/integration_v2/test_tool_result_format.py
new file mode 100644
index 000000000..271a86def
--- /dev/null
+++ b/tests/integration_v2/test_tool_result_format.py
@@ -0,0 +1,159 @@
+"""
+Integration tests for ToolResult format verification.
+
+Verifies that MCP tool wrappers correctly return ToolResult objects with
+both human-readable text content and structured JSON data.
+"""
+
+import pytest
+from fastmcp.client import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+from src.core.database.database_session import get_db_session
+from src.core.database.models import Principal
+from tests.integration_v2.conftest import add_required_setup_data
+from tests.utils.database_helpers import create_tenant_with_timestamps
+
+
+@pytest.fixture(scope="function")
+def setup_test_data(integration_db):
+    """Create test tenant and principal for MCP tests."""
+    with get_db_session() as session:
+        # Create test tenant
+        tenant = create_tenant_with_timestamps(
+            tenant_id="test_tool_result",
+            name="Test Tool Result Tenant",
+            subdomain="test-tool-result",
+            is_active=True,
+            ad_server="mock",
+            authorized_emails=["test@example.com"],
+        )
+        session.add(tenant)
+        session.flush()
+
+        # Add required setup data
+        add_required_setup_data(session, "test_tool_result")
+
+        # Create test principal
+        principal = Principal(
+            tenant_id="test_tool_result",
+            principal_id="test_principal",
+            name="Test Principal",
+            access_token="test_tool_result_token",
+            platform_mappings={"mock": {"id": "test_advertiser"}},
+        )
+        session.add(principal)
+        session.commit()
+
+    return "test_tool_result_token"
+
+
+@pytest.fixture
+async def mcp_client(mcp_server, setup_test_data):
+    """Create MCP client with test authentication."""
+    headers = {"x-adcp-auth": setup_test_data}  # Use the token from setup_test_data
+    transport = StreamableHttpTransport(url=f"http://localhost:{mcp_server.port}/mcp/", headers=headers)
+    client = Client(transport=transport)
+    return client
+
+
+@pytest.mark.requires_server
+@pytest.mark.asyncio
+async def test_get_products_returns_tool_result(mcp_client):
+    """Verify get_products MCP wrapper returns ToolResult with correct structure."""
+    async with mcp_client as client:
+        result = await client.call_tool(
+            "get_products",
+            {"brief": "display ads", "brand_manifest": {"name": "Test Brand"}},
+        )
+
+        # Verify ToolResult structure
+        assert hasattr(result, "content"), "Result must have content attribute"
+        assert hasattr(result, "structured_content"), "Result must have structured_content attribute"
+
+        # Verify content is human-readable text
+        assert isinstance(result.content, list), "Content should be a list of content blocks"
+        assert len(result.content) > 0, "Content should not be empty"
+        text_content = result.content[0].text
+        assert isinstance(text_content, str), "Text content should be a string"
+        assert len(text_content) > 0, "Text content should not be empty"
+        # Verify it's human-readable, not JSON
+        assert not text_content.startswith("{"), "Text should be human-readable, not JSON"
+        assert "product" in text_content.lower(), "Text should mention products"
+
+        # Verify structured_content is JSON data
+        assert isinstance(result.structured_content, dict), "Structured content should be a dict"
+        assert "products" in result.structured_content, "Structured content should have products field"
+        assert isinstance(result.structured_content["products"], list), "Products should be a list"
+
+
+@pytest.mark.requires_server
+@pytest.mark.asyncio
+async def test_list_creative_formats_returns_tool_result(mcp_client):
+    """Verify list_creative_formats MCP wrapper returns ToolResult with correct structure."""
+    async with mcp_client as client:
+        result = await client.call_tool("list_creative_formats", {})
+
+        # Verify ToolResult structure
+        assert hasattr(result, "content"), "Result must have content attribute"
+        assert hasattr(result, "structured_content"), "Result must have structured_content attribute"
+
+        # Verify content is human-readable text
+        text_content = result.content[0].text
+        assert isinstance(text_content, str), "Text content should be a string"
+        assert len(text_content) > 0, "Text content should not be empty"
+        assert not text_content.startswith("{"), "Text should be human-readable, not JSON"
+        assert "format" in text_content.lower(), "Text should mention formats"
+
+        # Verify structured_content is JSON data
+        assert isinstance(result.structured_content, dict), "Structured content should be a dict"
+        assert "formats" in result.structured_content, "Structured content should have formats field"
+
+
+@pytest.mark.requires_server
+@pytest.mark.asyncio
+async def test_list_authorized_properties_returns_tool_result(mcp_client):
+    """Verify list_authorized_properties MCP wrapper returns ToolResult with correct structure."""
+    async with mcp_client as client:
+        result = await client.call_tool("list_authorized_properties", {})
+
+        # Verify ToolResult structure
+        assert hasattr(result, "content"), "Result must have content attribute"
+        assert hasattr(result, "structured_content"), "Result must have structured_content attribute"
+
+        # Verify content is human-readable text
+        text_content = result.content[0].text
+        assert isinstance(text_content, str), "Text content should be a string"
+        assert len(text_content) > 0, "Text content should not be empty"
+        assert not text_content.startswith("{"), "Text should be human-readable, not JSON"
+
+        # Verify structured_content is JSON data
+        assert isinstance(result.structured_content, dict), "Structured content should be a dict"
+        assert "publisher_domains" in result.structured_content, "Should have publisher_domains field"
+
+
+@pytest.mark.requires_server
+@pytest.mark.asyncio
+async def test_tool_result_content_differs_from_structured(mcp_client):
+    """Verify that text content is different from structured content (not just JSON dump)."""
+    async with mcp_client as client:
+        result = await client.call_tool(
+            "get_products",
+            {"brief": "video ads", "brand_manifest": {"name": "Test Brand"}},
+        )
+
+        text_content = result.content[0].text
+        structured_content = result.structured_content
+
+        # Text should be a summary, not the full JSON
+        import json
+
+        json_dump = json.dumps(structured_content)
+        assert text_content != json_dump, "Text should be a summary, not full JSON dump"
+
+        # Text should be human-readable (not necessarily shorter - empty results can have longer messages)
+        assert "product" in text_content.lower(), "Text should describe products"
+        # Common patterns: "Found N products" or "No products"
+        assert any(
+            phrase in text_content.lower() for phrase in ["found", "no products", "products matching"]
+        ), "Text should have human-readable summary"
diff --git a/tests/unit/test_parse_tool_result.py b/tests/unit/test_parse_tool_result.py
new file mode 100644
index 000000000..f44ebe9f7
--- /dev/null
+++ b/tests/unit/test_parse_tool_result.py
@@ -0,0 +1,72 @@
+"""
+Unit tests for parse_tool_result helper function.
+
+Tests that the helper correctly extracts structured data from ToolResult.
+"""
+
+from typing import Any
+
+import pytest
+
+from tests.e2e.adcp_request_builder import parse_tool_result
+
+
+class MockToolResult:
+    """Mock ToolResult format with structured_content field."""
+
+    def __init__(self, structured_content: dict[str, Any] | None):
+        self.structured_content = structured_content
+
+
+class TestParseToolResult:
+    """Test parse_tool_result helper function."""
+
+    def test_parse_with_structured_content(self):
+        """Test parsing ToolResult with structured_content field."""
+        expected_data = {"products": [{"product_id": "p1", "name": "Test Product"}], "count": 1}
+
+        result = MockToolResult(structured_content=expected_data)
+        parsed = parse_tool_result(result)
+
+        assert parsed == expected_data
+        assert "products" in parsed
+        assert len(parsed["products"]) == 1
+
+    def test_parse_complex_nested_data(self):
+        """Test parsing complex nested data structures."""
+        complex_data = {
+            "media_buy_id": "mb_123",
+            "packages": [
+                {"package_id": "pkg1", "budget": 5000.0, "targeting": {"countries": ["US", "CA"]}},
+                {"package_id": "pkg2", "budget": 3000.0, "targeting": {"countries": ["UK"]}},
+            ],
+            "status": "active",
+            "metadata": {"created_at": "2025-10-27T12:00:00Z"},
+        }
+
+        result = MockToolResult(structured_content=complex_data)
+        parsed = parse_tool_result(result)
+
+        assert parsed == complex_data
+        assert len(parsed["packages"]) == 2
+        assert parsed["packages"][0]["budget"] == 5000.0
+
+    def test_parse_invalid_result_raises_error(self):
+        """Test that result without structured_content raises ValueError."""
+
+        class InvalidResult:
+            """Result with no structured_content."""
+
+            pass
+
+        result = InvalidResult()
+
+        with pytest.raises(ValueError, match="has no structured_content field"):
+            parse_tool_result(result)
+
+    def test_parse_none_structured_content_raises_error(self):
+        """Test that result with None structured_content raises error."""
+        result = MockToolResult(structured_content=None)
+
+        with pytest.raises(ValueError, match="has no structured_content field"):
+            parse_tool_result(result)