adcp 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

adcp/__init__.py

@@ -20,33 +20,120 @@ from adcp.exceptions import (
 )
 from adcp.types.core import AgentConfig, Protocol, TaskResult, TaskStatus, WebhookMetadata
 from adcp.types.generated import (
+    ActivateSignalError,
+    # Request/Response types
     ActivateSignalRequest,
     ActivateSignalResponse,
+    ActivateSignalSuccess,
+    ActivationKey,
+    AgentDeployment,
+    AgentDestination,
+    BothPreviewRender,
+    # Brand types
+    BrandManifest,
+    BrandManifestRef,
+    BuildCreativeRequest,
+    BuildCreativeResponse,
+    # Channel types
+    Channels,
+    CreateMediaBuyError,
     CreateMediaBuyRequest,
     CreateMediaBuyResponse,
+    CreateMediaBuySuccess,
+    # Creative types
+    CreativeAsset,
+    CreativeAssignment,
+    CreativeManifest,
+    CreativePolicy,
+    DaastAsset,
+    # Metrics types
+    DeliveryMetrics,
+    # Delivery types
+    DeliveryType,
+    Deployment,
+    # Deployment types
+    Destination,
+    Error,
+    Format,
+    FormatId,
+    FrequencyCap,
     GetMediaBuyDeliveryRequest,
     GetMediaBuyDeliveryResponse,
     GetProductsRequest,
     GetProductsResponse,
     GetSignalsRequest,
     GetSignalsResponse,
+    HtmlPreviewRender,
+    InlineDaastAsset,
+    InlineVastAsset,
+    Key_valueActivationKey,
     ListAuthorizedPropertiesRequest,
     ListAuthorizedPropertiesResponse,
     ListCreativeFormatsRequest,
     ListCreativeFormatsResponse,
     ListCreativesRequest,
     ListCreativesResponse,
+    Measurement,
+    # Core domain types
     MediaBuy,
+    # Status enums
+    MediaBuyStatus,
+    # Sub-asset types
+    MediaSubAsset,
+    Pacing,
+    Package,
+    PackageStatus,
+    PerformanceFeedback,
+    Placement,
+    PlatformDeployment,
+    PlatformDestination,
+    PreviewCreativeRequest,
+    PreviewCreativeResponse,
+    # Preview render types
+    PreviewRender,
+    PricingModel,
+    # Pricing types
+    PricingOption,
     Product,
+    PromotedProducts,
+    # Property and placement types
+    Property,
+    ProtocolEnvelope,
     ProvidePerformanceFeedbackRequest,
     ProvidePerformanceFeedbackResponse,
+    PushNotificationConfig,
+    ReportingCapabilities,
+    Response,
+    Segment_idActivationKey,
+    StandardFormatIds,
+    StartTiming,
+    SubAsset,
+    SyncCreativesError,
     SyncCreativesRequest,
     SyncCreativesResponse,
+    SyncCreativesSuccess,
+    # Targeting types
+    Targeting,
+    # Task types
+    TaskType,
+    TextSubAsset,
+    UpdateMediaBuyError,
     UpdateMediaBuyRequest,
     UpdateMediaBuyResponse,
+    UpdateMediaBuySuccess,
+    UrlDaastAsset,
+    UrlPreviewRender,
+    UrlVastAsset,
+    # Asset delivery types (VAST/DAAST)
+    VastAsset,
+    # Protocol types
+    WebhookPayload,
+)
+from adcp.types.generated import (
+    TaskStatus as GeneratedTaskStatus,
 )
 
-__version__ = "1.1.0"
+__version__ = "1.2.1"
 
 __all__ = [
     # Client classes
@@ -67,30 +154,113 @@ __all__ = [
     "ADCPToolNotFoundError",
     "ADCPWebhookError",
     "ADCPWebhookSignatureError",
-    # Generated request/response types
-    "GetProductsRequest",
-    "GetProductsResponse",
+    # Request/Response types
+    "ActivateSignalRequest",
+    "ActivateSignalResponse",
+    "ActivateSignalSuccess",
+    "ActivateSignalError",
+    "ActivationKey",
+    "Segment_idActivationKey",
+    "Key_valueActivationKey",
+    "BuildCreativeRequest",
+    "BuildCreativeResponse",
     "CreateMediaBuyRequest",
     "CreateMediaBuyResponse",
-    "UpdateMediaBuyRequest",
-    "UpdateMediaBuyResponse",
-    "SyncCreativesRequest",
-    "SyncCreativesResponse",
-    "ListCreativesRequest",
-    "ListCreativesResponse",
-    "ListCreativeFormatsRequest",
-    "ListCreativeFormatsResponse",
+    "CreateMediaBuySuccess",
+    "CreateMediaBuyError",
     "GetMediaBuyDeliveryRequest",
     "GetMediaBuyDeliveryResponse",
-    "ListAuthorizedPropertiesRequest",
-    "ListAuthorizedPropertiesResponse",
+    "GetProductsRequest",
+    "GetProductsResponse",
     "GetSignalsRequest",
     "GetSignalsResponse",
-    "ActivateSignalRequest",
-    "ActivateSignalResponse",
+    "ListAuthorizedPropertiesRequest",
+    "ListAuthorizedPropertiesResponse",
+    "ListCreativeFormatsRequest",
+    "ListCreativeFormatsResponse",
+    "ListCreativesRequest",
+    "ListCreativesResponse",
+    "PreviewCreativeRequest",
+    "PreviewCreativeResponse",
     "ProvidePerformanceFeedbackRequest",
     "ProvidePerformanceFeedbackResponse",
+    "SyncCreativesRequest",
+    "SyncCreativesResponse",
+    "SyncCreativesSuccess",
+    "SyncCreativesError",
+    "UpdateMediaBuyRequest",
+    "UpdateMediaBuyResponse",
+    "UpdateMediaBuySuccess",
+    "UpdateMediaBuyError",
     # Core domain types
-    "Product",
     "MediaBuy",
+    "Product",
+    "Package",
+    "Error",
+    # Creative types
+    "CreativeAsset",
+    "CreativeManifest",
+    "CreativeAssignment",
+    "CreativePolicy",
+    "Format",
+    "FormatId",
+    # Property and placement types
+    "Property",
+    "Placement",
+    # Targeting types
+    "Targeting",
+    "FrequencyCap",
+    "Pacing",
+    # Brand types
+    "BrandManifest",
+    "BrandManifestRef",
+    # Metrics types
+    "DeliveryMetrics",
+    "Measurement",
+    "PerformanceFeedback",
+    # Status enums
+    "MediaBuyStatus",
+    "PackageStatus",
+    # Pricing types
+    "PricingOption",
+    "PricingModel",
+    # Delivery types
+    "DeliveryType",
+    "StartTiming",
+    # Channel types
+    "Channels",
+    "StandardFormatIds",
+    # Protocol types
+    "WebhookPayload",
+    "ProtocolEnvelope",
+    "Response",
+    "PromotedProducts",
+    "PushNotificationConfig",
+    "ReportingCapabilities",
+    # Deployment types
+    "Destination",
+    "Deployment",
+    "PlatformDestination",
+    "AgentDestination",
+    "PlatformDeployment",
+    "AgentDeployment",
+    # Sub-asset types
+    "MediaSubAsset",
+    "SubAsset",
+    "TextSubAsset",
+    # Asset delivery types (VAST/DAAST)
+    "VastAsset",
+    "UrlVastAsset",
+    "InlineVastAsset",
+    "DaastAsset",
+    "UrlDaastAsset",
+    "InlineDaastAsset",
+    # Preview render types
+    "PreviewRender",
+    "UrlPreviewRender",
+    "HtmlPreviewRender",
+    "BothPreviewRender",
+    # Task types
+    "TaskType",
+    "GeneratedTaskStatus",
 ]

adcp/client.py

@@ -11,6 +11,8 @@ from collections.abc import Callable
 from datetime import datetime, timezone
 from typing import Any
 
+from pydantic import BaseModel
+
 from adcp.exceptions import ADCPWebhookSignatureError
 from adcp.protocols.a2a import A2AAdapter
 from adcp.protocols.base import ProtocolAdapter
@@ -154,7 +156,9 @@ class ADCPClient:
             )
         )
 
-        result = self.adapter._parse_response(raw_result, GetProductsResponse)
+        result: TaskResult[GetProductsResponse] = self.adapter._parse_response(
+            raw_result, GetProductsResponse
+        )
 
         if fetch_previews and result.success and result.data and creative_agent_client:
             from adcp.utils.preview_cache import add_preview_urls_to_products
@@ -215,7 +219,9 @@ class ADCPClient:
             )
         )
 
-        result = self.adapter._parse_response(raw_result, ListCreativeFormatsResponse)
+        result: TaskResult[ListCreativeFormatsResponse] = self.adapter._parse_response(
+            raw_result, ListCreativeFormatsResponse
+        )
 
         if fetch_previews and result.success and result.data:
             from adcp.utils.preview_cache import add_preview_urls_to_formats
@@ -617,15 +623,16 @@ class ADCPClient:
         from adcp.utils.response_parser import parse_json_or_text
 
         # Map task types to their response types (using string literals, not enum)
-        response_type_map: dict[str, type] = {
+        # Note: Some response types are Union types (e.g., ActivateSignalResponse = Success | Error)
+        response_type_map: dict[str, type[BaseModel] | Any] = {
             "get_products": GetProductsResponse,
             "list_creative_formats": ListCreativeFormatsResponse,
-            "sync_creatives": SyncCreativesResponse,
+            "sync_creatives": SyncCreativesResponse,  # Union type
             "list_creatives": ListCreativesResponse,
             "get_media_buy_delivery": GetMediaBuyDeliveryResponse,
             "list_authorized_properties": ListAuthorizedPropertiesResponse,
             "get_signals": GetSignalsResponse,
-            "activate_signal": ActivateSignalResponse,
+            "activate_signal": ActivateSignalResponse,  # Union type
             "provide_performance_feedback": ProvidePerformanceFeedbackResponse,
         }
 

adcp/protocols/base.py

@@ -30,15 +30,18 @@ class ProtocolAdapter(ABC):
     # Helper methods for response parsing
     # ========================================================================
 
-    def _parse_response(self, raw_result: TaskResult[Any], response_type: type[T]) -> TaskResult[T]:
+    def _parse_response(
+        self, raw_result: TaskResult[Any], response_type: type[T] | Any
+    ) -> TaskResult[T]:
         """
         Parse raw TaskResult into typed TaskResult.
 
         Handles both MCP content arrays and A2A dict responses.
+        Supports both single types and Union types (for oneOf discriminated unions).
 
         Args:
             raw_result: Raw TaskResult from adapter
-            response_type: Expected Pydantic response type
+            response_type: Expected Pydantic response type (can be a Union type)
 
         Returns:
             Typed TaskResult

adcp/types/generated.py

@@ -14,19 +14,9 @@ from __future__ import annotations
 import re
 from typing import Any, Literal
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
-# ============================================================================
-# MISSING SCHEMA TYPES (referenced but not provided by upstream)
-# ============================================================================
-
-# These types are referenced in schemas but don't have schema files
-# Defining them as type aliases to maintain type safety
-PackageRequest = dict[str, Any]
-PushNotificationConfig = dict[str, Any]
-ReportingCapabilities = dict[str, Any]
-
 
 # ============================================================================
 # CORE DOMAIN TYPES
@@ -125,9 +115,22 @@ class BrandManifest(BaseModel):
     metadata: dict[str, Any] | None = Field(None, description="Additional brand metadata")
 
 
-# Type alias for Brand Manifest Reference
 # Brand manifest provided either as an inline object or a URL string pointing to a hosted manifest
-BrandManifestRef = Any
+
+class BrandManifestRefVariant1(BaseModel):
+    """Inline brand manifest object"""
+
+    pass
+
+
+class BrandManifestRefVariant2(BaseModel):
+    """URL to a hosted brand manifest JSON file. The manifest at this URL must conform to the brand-manifest.json schema."""
+
+    pass
+
+
+# Union type for Brand Manifest Reference
+BrandManifestRef = BrandManifestRefVariant1 | BrandManifestRefVariant2
 
 
 class Format(BaseModel):
@@ -255,18 +258,46 @@ class PerformanceFeedback(BaseModel):
     applied_at: str | None = Field(None, description="ISO 8601 timestamp when feedback was applied to optimization algorithms")
 
 
-# Type alias for Start Timing
 # Campaign start timing: 'asap' or ISO 8601 date-time
-StartTiming = Any
 
+class StartTimingVariant1(BaseModel):
+    """Start campaign as soon as possible"""
+
+    pass
+
+
+class StartTimingVariant2(BaseModel):
+    """Scheduled start date/time in ISO 8601 format"""
+
+    pass
+
+
+# Union type for Start Timing
+StartTiming = StartTimingVariant1 | StartTimingVariant2
+
+
+# Sub-asset for multi-asset creative formats, including carousel images and native ad template variables
+
+class MediaSubAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
 
-class SubAsset(BaseModel):
-    """Sub-asset for multi-asset creative formats, including carousel images and native ad template variables"""
+    asset_kind: Literal["media"] = Field(description="Discriminator indicating this is a media asset with content_uri")
+    asset_type: str = Field(description="Type of asset. Common types: thumbnail_image, product_image, featured_image, logo")
+    asset_id: str = Field(description="Unique identifier for the asset within the creative")
+    content_uri: str = Field(description="URL for media assets (images, videos, etc.)")
 
-    asset_type: str | None = Field(None, description="Type of asset. Common types: headline, body_text, thumbnail_image, product_image, featured_image, logo, cta_text, price_text, sponsor_name, author_name, click_url")
-    asset_id: str | None = Field(None, description="Unique identifier for the asset within the creative")
-    content_uri: str | None = Field(None, description="URL for media assets (images, videos, etc.)")
-    content: Any | None = Field(None, description="Text content for text-based assets like headlines, body text, CTA text, etc.")
+
+class TextSubAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    asset_kind: Literal["text"] = Field(description="Discriminator indicating this is a text asset with content")
+    asset_type: str = Field(description="Type of asset. Common types: headline, body_text, cta_text, price_text, sponsor_name, author_name, click_url")
+    asset_id: str = Field(description="Unique identifier for the asset within the creative")
+    content: Any = Field(description="Text content for text-based assets like headlines, body text, CTA text, etc.")
+
+
+# Union type for Sub-Asset
+SubAsset = MediaSubAsset | TextSubAsset
 
 
 class WebhookPayload(BaseModel):
@@ -281,7 +312,7 @@ class WebhookPayload(BaseModel):
     message: str | None = Field(None, description="Human-readable summary of the current task state. Provides context about what happened and what action may be needed.")
     context_id: str | None = Field(None, description="Session/conversation identifier. Use this to continue the conversation if input-required status needs clarification or additional parameters.")
     progress: dict[str, Any] | None = Field(None, description="Progress information for tasks still in 'working' state. Rarely seen in webhooks since 'working' tasks typically complete synchronously, but may appear if a task transitions from 'submitted' to 'working'.")
-    result: Any | None = Field(None, description="Task-specific payload for this status update. For 'completed', contains the final result. For 'input-required', may contain approval or clarification context. Optional for non-terminal updates.")
+    result: Any | None = Field(None, description="Task-specific payload for this status update. Validated against the appropriate response schema based on task_type.")
     error: Any | None = Field(None, description="Error message for failed tasks. Only present when status is 'failed'.")
 
 
@@ -314,6 +345,97 @@ class PromotedProducts(BaseModel):
     manifest_query: str | None = Field(None, description="Natural language query to select products from the brand manifest (e.g., 'all Kraft Heinz pasta sauces', 'organic products under $20')")
 
 
+# A destination platform where signals can be activated (DSP, sales agent, etc.)
+
+class PlatformDestination(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["platform"] = Field(description="Discriminator indicating this is a platform-based destination")
+    platform: str = Field(description="Platform identifier for DSPs (e.g., 'the-trade-desk', 'amazon-dsp')")
+    account: str | None = Field(None, description="Optional account identifier on the platform")
+
+
+class AgentDestination(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["agent"] = Field(description="Discriminator indicating this is an agent URL-based destination")
+    agent_url: str = Field(description="URL identifying the destination agent (for sales agents, etc.)")
+    account: str | None = Field(None, description="Optional account identifier on the agent")
+
+
+# Union type for Destination
+Destination = PlatformDestination | AgentDestination
+
+
+# A signal deployment to a specific destination platform with activation status and key
+
+class PlatformDeployment(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["platform"] = Field(description="Discriminator indicating this is a platform-based deployment")
+    platform: str = Field(description="Platform identifier for DSPs")
+    account: str | None = Field(None, description="Account identifier if applicable")
+    is_live: bool = Field(description="Whether signal is currently active on this destination")
+    activation_key: ActivationKey | None = Field(None, description="The key to use for targeting. Only present if is_live=true AND requester has access to this destination.")
+    estimated_activation_duration_minutes: float | None = Field(None, description="Estimated time to activate if not live, or to complete activation if in progress")
+    deployed_at: str | None = Field(None, description="Timestamp when activation completed (if is_live=true)")
+
+
+class AgentDeployment(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["agent"] = Field(description="Discriminator indicating this is an agent URL-based deployment")
+    agent_url: str = Field(description="URL identifying the destination agent")
+    account: str | None = Field(None, description="Account identifier if applicable")
+    is_live: bool = Field(description="Whether signal is currently active on this destination")
+    activation_key: ActivationKey | None = Field(None, description="The key to use for targeting. Only present if is_live=true AND requester has access to this destination.")
+    estimated_activation_duration_minutes: float | None = Field(None, description="Estimated time to activate if not live, or to complete activation if in progress")
+    deployed_at: str | None = Field(None, description="Timestamp when activation completed (if is_live=true)")
+
+
+# Union type for Deployment
+Deployment = PlatformDeployment | AgentDeployment
+
+
+# Universal identifier for using a signal on a destination platform. Can be either a segment ID or a key-value pair depending on the platform's targeting mechanism.
+
+class Segment_idActivationKey(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["segment_id"] = Field(description="Segment ID based targeting")
+    segment_id: str = Field(description="The platform-specific segment identifier to use in campaign targeting")
+
+
+class Key_valueActivationKey(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["key_value"] = Field(description="Key-value pair based targeting")
+    key: str = Field(description="The targeting parameter key")
+    value: str = Field(description="The targeting parameter value")
+
+
+# Union type for Activation Key
+ActivationKey = Segment_idActivationKey | Key_valueActivationKey
+
+
+class PushNotificationConfig(BaseModel):
+    """Webhook configuration for asynchronous task notifications. Uses A2A-compatible PushNotificationConfig structure. Supports Bearer tokens (simple) or HMAC signatures (production-recommended)."""
+
+    url: str = Field(description="Webhook endpoint URL for task status notifications")
+    token: str | None = Field(None, description="Optional client-provided token for webhook validation. Echoed back in webhook payload to validate request authenticity.")
+    authentication: dict[str, Any] = Field(description="Authentication configuration for webhook delivery (A2A-compatible)")
+
+
+class ReportingCapabilities(BaseModel):
+    """Reporting capabilities available for a product"""
+
+    available_reporting_frequencies: list[Literal["hourly", "daily", "monthly"]] = Field(description="Supported reporting frequency options")
+    expected_delay_minutes: int = Field(description="Expected delay in minutes before reporting data becomes available (e.g., 240 for 4-hour delay)")
+    timezone: str = Field(description="Timezone for reporting periods. Use 'UTC' or IANA timezone (e.g., 'America/New_York'). Critical for daily/monthly frequency alignment.")
+    supports_webhooks: bool = Field(description="Whether this product supports webhook-based reporting notifications")
+    available_metrics: list[Literal["impressions", "spend", "clicks", "ctr", "video_completions", "completion_rate", "conversions", "viewability", "engagement_rate"]] = Field(description="Metrics available in reporting. Impressions and spend are always implicitly included.")
+
+
 # Type alias for Advertising Channels
 # Standard advertising channels supported by AdCP
 Channels = Literal["display", "video", "audio", "native", "dooh", "ctv", "podcast", "retail", "social"]
@@ -354,9 +476,46 @@ TaskStatus = Literal["submitted", "working", "input-required", "completed", "can
 PricingModel = Literal["cpm", "vcpm", "cpc", "cpcv", "cpv", "cpp", "flat_rate"]
 
 
-# Type alias for Pricing Option
 # A pricing model option offered by a publisher for a product. Each pricing model has its own schema with model-specific requirements.
-PricingOption = Any
+
+class PricingOptionVariant1(BaseModel):
+    pass
+
+
+class PricingOptionVariant2(BaseModel):
+    pass
+
+
+class PricingOptionVariant3(BaseModel):
+    pass
+
+
+class PricingOptionVariant4(BaseModel):
+    pass
+
+
+class PricingOptionVariant5(BaseModel):
+    pass
+
+
+class PricingOptionVariant6(BaseModel):
+    pass
+
+
+class PricingOptionVariant7(BaseModel):
+    pass
+
+
+class PricingOptionVariant8(BaseModel):
+    pass
+
+
+class PricingOptionVariant9(BaseModel):
+    pass
+
+
+# Union type for Pricing Option
+PricingOption = PricingOptionVariant1 | PricingOptionVariant2 | PricingOptionVariant3 | PricingOptionVariant4 | PricingOptionVariant5 | PricingOptionVariant6 | PricingOptionVariant7 | PricingOptionVariant8 | PricingOptionVariant9
 
 
 # Type alias for Standard Format IDs
@@ -364,17 +523,118 @@ PricingOption = Any
 StandardFormatIds = Literal["display_300x250", "display_728x90", "display_320x50", "display_160x600", "display_970x250", "display_336x280", "display_expandable_300x250", "display_expandable_728x90", "display_interstitial_320x480", "display_interstitial_desktop", "display_dynamic_300x250", "display_responsive", "native_in_feed", "native_content_recommendation", "native_product", "video_skippable_15s", "video_skippable_30s", "video_non_skippable_15s", "video_non_skippable_30s", "video_outstream_autoplay", "video_vertical_story", "video_rewarded_30s", "video_pause_ad", "video_ctv_non_skippable_30s", "audio_standard_15s", "audio_standard_30s", "audio_podcast_host_read", "audio_programmatic", "universal_carousel", "universal_canvas", "universal_takeover", "universal_gallery", "universal_reveal", "dooh_landscape_static", "dooh_portrait_video"]
 
 
+# VAST (Video Ad Serving Template) tag for third-party video ad serving
+
+class UrlVastAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    delivery_type: Literal["url"] = Field(description="Discriminator indicating VAST is delivered via URL endpoint")
+    url: str = Field(description="URL endpoint that returns VAST XML")
+    vast_version: Literal["2.0", "3.0", "4.0", "4.1", "4.2"] | None = Field(None, description="VAST specification version")
+    vpaid_enabled: bool | None = Field(None, description="Whether VPAID (Video Player-Ad Interface Definition) is supported")
+    duration_ms: int | None = Field(None, description="Expected video duration in milliseconds (if known)")
+    tracking_events: list[Literal["start", "firstQuartile", "midpoint", "thirdQuartile", "complete", "impression", "click", "pause", "resume", "skip", "mute", "unmute", "fullscreen", "exitFullscreen", "playerExpand", "playerCollapse"]] | None = Field(None, description="Tracking events supported by this VAST tag")
+
+
+class InlineVastAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    delivery_type: Literal["inline"] = Field(description="Discriminator indicating VAST is delivered as inline XML content")
+    content: str = Field(description="Inline VAST XML content")
+    vast_version: Literal["2.0", "3.0", "4.0", "4.1", "4.2"] | None = Field(None, description="VAST specification version")
+    vpaid_enabled: bool | None = Field(None, description="Whether VPAID (Video Player-Ad Interface Definition) is supported")
+    duration_ms: int | None = Field(None, description="Expected video duration in milliseconds (if known)")
+    tracking_events: list[Literal["start", "firstQuartile", "midpoint", "thirdQuartile", "complete", "impression", "click", "pause", "resume", "skip", "mute", "unmute", "fullscreen", "exitFullscreen", "playerExpand", "playerCollapse"]] | None = Field(None, description="Tracking events supported by this VAST tag")
+
+
+# Union type for VAST Asset
+VastAsset = UrlVastAsset | InlineVastAsset
+
+
+# DAAST (Digital Audio Ad Serving Template) tag for third-party audio ad serving
+
+class UrlDaastAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    delivery_type: Literal["url"] = Field(description="Discriminator indicating DAAST is delivered via URL endpoint")
+    url: str = Field(description="URL endpoint that returns DAAST XML")
+    daast_version: Literal["1.0", "1.1"] | None = Field(None, description="DAAST specification version")
+    duration_ms: int | None = Field(None, description="Expected audio duration in milliseconds (if known)")
+    tracking_events: list[Literal["start", "firstQuartile", "midpoint", "thirdQuartile", "complete", "impression", "pause", "resume", "skip", "mute", "unmute"]] | None = Field(None, description="Tracking events supported by this DAAST tag")
+    companion_ads: bool | None = Field(None, description="Whether companion display ads are included")
+
+
+class InlineDaastAsset(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    delivery_type: Literal["inline"] = Field(description="Discriminator indicating DAAST is delivered as inline XML content")
+    content: str = Field(description="Inline DAAST XML content")
+    daast_version: Literal["1.0", "1.1"] | None = Field(None, description="DAAST specification version")
+    duration_ms: int | None = Field(None, description="Expected audio duration in milliseconds (if known)")
+    tracking_events: list[Literal["start", "firstQuartile", "midpoint", "thirdQuartile", "complete", "impression", "pause", "resume", "skip", "mute", "unmute"]] | None = Field(None, description="Tracking events supported by this DAAST tag")
+    companion_ads: bool | None = Field(None, description="Whether companion display ads are included")
+
+
+# Union type for DAAST Asset
+DaastAsset = UrlDaastAsset | InlineDaastAsset
+
+
+# A single rendered piece of a creative preview with discriminated output format
+
+class UrlPreviewRender(BaseModel):
+    """URL-only preview format"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    render_id: str = Field(description="Unique identifier for this rendered piece within the variant")
+    output_format: Literal["url"] = Field(description="Discriminator indicating preview_url is provided")
+    preview_url: str = Field(description="URL to an HTML page that renders this piece. Can be embedded in an iframe.")
+    role: str = Field(description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles.")
+    dimensions: dict[str, Any] | None = Field(None, description="Dimensions for this rendered piece")
+    embedding: dict[str, Any] | None = Field(None, description="Optional security and embedding metadata for safe iframe integration")
+
+
+class HtmlPreviewRender(BaseModel):
+    """HTML-only preview format"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    render_id: str = Field(description="Unique identifier for this rendered piece within the variant")
+    output_format: Literal["html"] = Field(description="Discriminator indicating preview_html is provided")
+    preview_html: str = Field(description="Raw HTML for this rendered piece. Can be embedded directly in the page without iframe. Security warning: Only use with trusted creative agents as this bypasses iframe sandboxing.")
+    role: str = Field(description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles.")
+    dimensions: dict[str, Any] | None = Field(None, description="Dimensions for this rendered piece")
+    embedding: dict[str, Any] | None = Field(None, description="Optional security and embedding metadata")
+
+
+class BothPreviewRender(BaseModel):
+    """Both URL and HTML preview format"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    render_id: str = Field(description="Unique identifier for this rendered piece within the variant")
+    output_format: Literal["both"] = Field(description="Discriminator indicating both preview_url and preview_html are provided")
+    preview_url: str = Field(description="URL to an HTML page that renders this piece. Can be embedded in an iframe.")
+    preview_html: str = Field(description="Raw HTML for this rendered piece. Can be embedded directly in the page without iframe. Security warning: Only use with trusted creative agents as this bypasses iframe sandboxing.")
+    role: str = Field(description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles.")
+    dimensions: dict[str, Any] | None = Field(None, description="Dimensions for this rendered piece")
+    embedding: dict[str, Any] | None = Field(None, description="Optional security and embedding metadata for safe iframe integration")
+
+
+# Union type for Preview Render
+PreviewRender = UrlPreviewRender | HtmlPreviewRender | BothPreviewRender
+
+
 
 # ============================================================================
 # TASK REQUEST/RESPONSE TYPES
 # ============================================================================
 
 class ActivateSignalRequest(BaseModel):
-    """Request parameters for activating a signal on a specific platform/account"""
+    """Request parameters for activating a signal on a specific destination"""
 
     signal_agent_segment_id: str = Field(description="The universal identifier for the signal to activate")
-    platform: str = Field(description="The target platform for activation")
-    account: str | None = Field(None, description="Account identifier (required for account-specific activation)")
+    destinations: list[Destination] = Field(description="Target destination(s) for activation. If the authenticated caller matches one of these destinations, activation keys will be included in the response.")
 
 
 class BuildCreativeRequest(BaseModel):
@@ -419,7 +679,7 @@ class GetSignalsRequest(BaseModel):
     """Request parameters for discovering signals based on description"""
 
     signal_spec: str = Field(description="Natural language description of the desired signals")
-    deliver_to: dict[str, Any] = Field(description="Where the signals need to be delivered")
+    deliver_to: dict[str, Any] = Field(description="Destination platforms where signals need to be activated")
     filters: dict[str, Any] | None = Field(None, description="Filters to refine results")
     max_results: int | None = Field(None, description="Maximum number of results to return")
 
@@ -456,6 +716,21 @@ class ListCreativesRequest(BaseModel):
     fields: list[Literal["creative_id", "name", "format", "status", "created_date", "updated_date", "tags", "assignments", "performance", "sub_assets"]] | None = Field(None, description="Specific fields to include in response (omit for all fields)")
 
 
+class PackageRequest(BaseModel):
+    """Package configuration for media buy creation"""
+
+    buyer_ref: str = Field(description="Buyer's reference identifier for this package")
+    product_id: str = Field(description="Product ID for this package")
+    format_ids: list[FormatId] | None = Field(None, description="Array of format IDs that will be used for this package - must be supported by the product. If omitted, defaults to all formats supported by the product.")
+    budget: float = Field(description="Budget allocation for this package in the media buy's currency")
+    pacing: Pacing | None = None
+    pricing_option_id: str = Field(description="ID of the selected pricing option from the product's pricing_options array")
+    bid_price: float | None = Field(None, description="Bid price for auction-based CPM pricing (required if using cpm-auction-option)")
+    targeting_overlay: Targeting | None = None
+    creative_ids: list[str] | None = Field(None, description="Creative IDs to assign to this package at creation time (references existing library creatives)")
+    creatives: list[CreativeAsset] | None = Field(None, description="Full creative objects to upload and assign to this package at creation time (alternative to creative_ids - creatives will be added to library). Supports both static and generative creatives.")
+
+
 class ProvidePerformanceFeedbackRequest(BaseModel):
     """Request payload for provide_performance_feedback task"""
 
@@ -480,6 +755,22 @@ class SyncCreativesRequest(BaseModel):
     push_notification_config: PushNotificationConfig | None = Field(None, description="Optional webhook configuration for async sync notifications. Publisher will send webhook when sync completes if operation takes longer than immediate response time (typically for large bulk operations or manual approval/HITL).")
 
 
+class TasksGetRequest(BaseModel):
+    """Request parameters for retrieving a specific task by ID with optional conversation history across all AdCP domains"""
+
+    task_id: str = Field(description="Unique identifier of the task to retrieve")
+    include_history: bool | None = Field(None, description="Include full conversation history for this task (may increase response size)")
+
+
+class TasksListRequest(BaseModel):
+    """Request parameters for listing and filtering async tasks across all AdCP domains with state reconciliation capabilities"""
+
+    filters: dict[str, Any] | None = Field(None, description="Filter criteria for querying tasks")
+    sort: dict[str, Any] | None = Field(None, description="Sorting parameters")
+    pagination: dict[str, Any] | None = Field(None, description="Pagination parameters")
+    include_history: bool | None = Field(None, description="Include full conversation history for each task (may significantly increase response size)")
+
+
 class UpdateMediaBuyRequest(BaseModel):
     """Request parameters for updating campaign and package settings"""
 
@@ -492,30 +783,26 @@ class UpdateMediaBuyRequest(BaseModel):
     push_notification_config: PushNotificationConfig | None = Field(None, description="Optional webhook configuration for async update notifications. Publisher will send webhook when update completes if operation takes longer than immediate response time.")
 
 
-class ActivateSignalResponse(BaseModel):
-    """Response payload for activate_signal task"""
+# Response containing the transformed or generated creative manifest, ready for use with preview_creative or sync_creatives. Returns either the complete creative manifest OR error information, never both.
 
-    decisioning_platform_segment_id: str | None = Field(None, description="The platform-specific ID to use once activated")
-    estimated_activation_duration_minutes: float | None = Field(None, description="Estimated time to complete (optional)")
-    deployed_at: str | None = Field(None, description="Timestamp when activation completed (optional)")
-    errors: list[Error] | None = Field(None, description="Task-specific errors and warnings (e.g., activation failures, platform issues)")
+class BuildCreativeResponseVariant1(BaseModel):
+    """Success response - creative manifest generated successfully"""
 
-
-class BuildCreativeResponse(BaseModel):
-    """Response containing the transformed or generated creative manifest, ready for use with preview_creative or sync_creatives"""
+    model_config = ConfigDict(extra="forbid")
 
     creative_manifest: CreativeManifest = Field(description="The generated or transformed creative manifest")
-    errors: list[Error] | None = Field(None, description="Task-specific errors and warnings")
 
 
-class CreateMediaBuyResponse(BaseModel):
-    """Response payload for create_media_buy task"""
+class BuildCreativeResponseVariant2(BaseModel):
+    """Error response - creative generation failed"""
 
-    media_buy_id: str | None = Field(None, description="Publisher's unique identifier for the created media buy")
-    buyer_ref: str = Field(description="Buyer's reference identifier for this media buy")
-    creative_deadline: str | None = Field(None, description="ISO 8601 timestamp for creative upload deadline")
-    packages: list[dict[str, Any]] | None = Field(None, description="Array of created packages")
-    errors: list[Error] | None = Field(None, description="Task-specific errors and warnings (e.g., partial package creation failures)")
+    model_config = ConfigDict(extra="forbid")
+
+    errors: list[Error] = Field(description="Array of errors explaining why creative generation failed")
+
+
+# Union type for Build Creative Response
+BuildCreativeResponse = BuildCreativeResponseVariant1 | BuildCreativeResponseVariant2
 
 
 class GetMediaBuyDeliveryResponse(BaseModel):
@@ -577,28 +864,50 @@ class ListCreativesResponse(BaseModel):
     status_summary: dict[str, Any] | None = Field(None, description="Breakdown of creatives by status")
 
 
-class ProvidePerformanceFeedbackResponse(BaseModel):
-    """Response payload for provide_performance_feedback task"""
+# Response payload for provide_performance_feedback task. Returns either success confirmation OR error information, never both.
+
+class ProvidePerformanceFeedbackResponseVariant1(BaseModel):
+    """Success response - feedback received and processed"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    success: Literal[True] = Field(description="Whether the performance feedback was successfully received")
+
+
+class ProvidePerformanceFeedbackResponseVariant2(BaseModel):
+    """Error response - feedback rejected or could not be processed"""
+
+    model_config = ConfigDict(extra="forbid")
+
+    errors: list[Error] = Field(description="Array of errors explaining why feedback was rejected (e.g., invalid measurement period, missing campaign data)")
 
-    success: bool = Field(description="Whether the performance feedback was successfully received")
-    errors: list[Error] | None = Field(None, description="Task-specific errors and warnings (e.g., invalid measurement period, missing campaign data)")
 
+# Union type for Provide Performance Feedback Response
+ProvidePerformanceFeedbackResponse = ProvidePerformanceFeedbackResponseVariant1 | ProvidePerformanceFeedbackResponseVariant2
 
-class SyncCreativesResponse(BaseModel):
-    """Response from creative sync operation with results for each creative"""
 
-    dry_run: bool | None = Field(None, description="Whether this was a dry run (no actual changes made)")
-    creatives: list[dict[str, Any]] = Field(description="Results for each creative processed")
+class TasksGetResponse(BaseModel):
+    """Response containing detailed information about a specific task including status and optional conversation history across all AdCP domains"""
 
+    task_id: str = Field(description="Unique identifier for this task")
+    task_type: TaskType = Field(description="Type of AdCP operation")
+    domain: Literal["media-buy", "signals"] = Field(description="AdCP domain this task belongs to")
+    status: TaskStatus = Field(description="Current task status")
+    created_at: str = Field(description="When the task was initially created (ISO 8601)")
+    updated_at: str = Field(description="When the task was last updated (ISO 8601)")
+    completed_at: str | None = Field(None, description="When the task completed (ISO 8601, only for completed/failed/canceled tasks)")
+    has_webhook: bool | None = Field(None, description="Whether this task has webhook configuration")
+    progress: dict[str, Any] | None = Field(None, description="Progress information for long-running tasks")
+    error: dict[str, Any] | None = Field(None, description="Error details for failed tasks")
+    history: list[dict[str, Any]] | None = Field(None, description="Complete conversation history for this task (only included if include_history was true in request)")
 
-class UpdateMediaBuyResponse(BaseModel):
-    """Response payload for update_media_buy task"""
 
-    media_buy_id: str = Field(description="Publisher's identifier for the media buy")
-    buyer_ref: str = Field(description="Buyer's reference identifier for the media buy")
-    implementation_date: Any | None = Field(None, description="ISO 8601 timestamp when changes take effect (null if pending approval)")
-    affected_packages: list[dict[str, Any]] | None = Field(None, description="Array of packages that were modified")
-    errors: list[Error] | None = Field(None, description="Task-specific errors and warnings (e.g., partial update failures)")
+class TasksListResponse(BaseModel):
+    """Response from task listing query with filtered results and state reconciliation data across all AdCP domains"""
+
+    query_summary: dict[str, Any] = Field(description="Summary of the query that was executed")
+    tasks: list[dict[str, Any]] = Field(description="Array of tasks matching the query criteria")
+    pagination: dict[str, Any] = Field(description="Pagination information")
 
 
 
@@ -653,3 +962,211 @@ class PreviewCreativeResponse(BaseModel):
 
     # Batch mode field
     results: list[dict[str, Any]] | None = Field(default=None, description="Array of preview results for batch processing")
+
+
+# ============================================================================
+# ONEOF DISCRIMINATED UNIONS FOR RESPONSE TYPES
+# ============================================================================
+# These response types use oneOf semantics: success XOR error, never both.
+# Implemented as Union types with distinct Success/Error variants.
+
+
+class ActivateSignalSuccess(BaseModel):
+    """Successful signal activation response"""
+
+    decisioning_platform_segment_id: str = Field(
+        description="The platform-specific ID to use once activated"
+    )
+    estimated_activation_duration_minutes: float | None = None
+    deployed_at: str | None = None
+
+
+class ActivateSignalError(BaseModel):
+    """Failed signal activation response"""
+
+    errors: list[Error] = Field(description="Task-specific errors and warnings")
+
+
+# Override the generated ActivateSignalResponse type alias
+ActivateSignalResponse = ActivateSignalSuccess | ActivateSignalError
+
+
+class CreateMediaBuySuccess(BaseModel):
+    """Successful media buy creation response"""
+
+    media_buy_id: str = Field(description="The unique ID for the media buy")
+    buyer_ref: str = Field(description="The buyer's reference ID for this media buy")
+    packages: list[Package] = Field(
+        description="Array of approved packages. Each package is ready for creative assignment."
+    )
+    creative_deadline: str | None = Field(
+        None,
+        description="ISO 8601 date when creatives must be provided for launch",
+    )
+
+
+class CreateMediaBuyError(BaseModel):
+    """Failed media buy creation response"""
+
+    errors: list[Error] = Field(description="Task-specific errors and warnings")
+
+
+# Override the generated CreateMediaBuyResponse type alias
+CreateMediaBuyResponse = CreateMediaBuySuccess | CreateMediaBuyError
+
+
+class UpdateMediaBuySuccess(BaseModel):
+    """Successful media buy update response"""
+
+    media_buy_id: str = Field(description="The unique ID for the media buy")
+    buyer_ref: str = Field(description="The buyer's reference ID for this media buy")
+    packages: list[Package] = Field(
+        description="Array of updated packages reflecting the changes"
+    )
+
+
+class UpdateMediaBuyError(BaseModel):
+    """Failed media buy update response"""
+
+    errors: list[Error] = Field(description="Task-specific errors and warnings")
+
+
+# Override the generated UpdateMediaBuyResponse type alias
+UpdateMediaBuyResponse = UpdateMediaBuySuccess | UpdateMediaBuyError
+
+
+class SyncCreativesSuccess(BaseModel):
+    """Successful creative sync response"""
+
+    assignments: list[CreativeAssignment] = Field(
+        description="Array of creative assignments with updated status"
+    )
+
+
+class SyncCreativesError(BaseModel):
+    """Failed creative sync response"""
+
+    errors: list[Error] = Field(description="Task-specific errors and warnings")
+
+
+# Override the generated SyncCreativesResponse type alias
+SyncCreativesResponse = SyncCreativesSuccess | SyncCreativesError
+
+
+# Explicit exports for module interface
+__all__ = [
+    "ActivateSignalError",
+    "ActivateSignalRequest",
+    "ActivateSignalResponse",
+    "ActivateSignalSuccess",
+    "ActivationKey",
+    "AgentDeployment",
+    "AgentDestination",
+    "BothPreviewRender",
+    "BrandManifest",
+    "BrandManifestRef",
+    "BrandManifestRefVariant1",
+    "BrandManifestRefVariant2",
+    "BuildCreativeRequest",
+    "BuildCreativeResponse",
+    "BuildCreativeResponseVariant1",
+    "BuildCreativeResponseVariant2",
+    "Channels",
+    "CreateMediaBuyError",
+    "CreateMediaBuyRequest",
+    "CreateMediaBuyResponse",
+    "CreateMediaBuySuccess",
+    "CreativeAsset",
+    "CreativeAssignment",
+    "CreativeManifest",
+    "CreativePolicy",
+    "DaastAsset",
+    "DeliveryMetrics",
+    "DeliveryType",
+    "Deployment",
+    "Destination",
+    "Error",
+    "Format",
+    "FormatId",
+    "FrequencyCap",
+    "GetMediaBuyDeliveryRequest",
+    "GetMediaBuyDeliveryResponse",
+    "GetProductsRequest",
+    "GetProductsResponse",
+    "GetSignalsRequest",
+    "GetSignalsResponse",
+    "HtmlPreviewRender",
+    "InlineDaastAsset",
+    "InlineVastAsset",
+    "Key_valueActivationKey",
+    "ListAuthorizedPropertiesRequest",
+    "ListAuthorizedPropertiesResponse",
+    "ListCreativeFormatsRequest",
+    "ListCreativeFormatsResponse",
+    "ListCreativesRequest",
+    "ListCreativesResponse",
+    "Measurement",
+    "MediaBuy",
+    "MediaBuyStatus",
+    "MediaSubAsset",
+    "Pacing",
+    "Package",
+    "PackageRequest",
+    "PackageStatus",
+    "PerformanceFeedback",
+    "Placement",
+    "PlatformDeployment",
+    "PlatformDestination",
+    "PreviewCreativeRequest",
+    "PreviewCreativeResponse",
+    "PreviewRender",
+    "PricingModel",
+    "PricingOption",
+    "PricingOptionVariant1",
+    "PricingOptionVariant2",
+    "PricingOptionVariant3",
+    "PricingOptionVariant4",
+    "PricingOptionVariant5",
+    "PricingOptionVariant6",
+    "PricingOptionVariant7",
+    "PricingOptionVariant8",
+    "PricingOptionVariant9",
+    "Product",
+    "PromotedProducts",
+    "Property",
+    "ProtocolEnvelope",
+    "ProvidePerformanceFeedbackRequest",
+    "ProvidePerformanceFeedbackResponse",
+    "ProvidePerformanceFeedbackResponseVariant1",
+    "ProvidePerformanceFeedbackResponseVariant2",
+    "PushNotificationConfig",
+    "ReportingCapabilities",
+    "Response",
+    "Segment_idActivationKey",
+    "StandardFormatIds",
+    "StartTiming",
+    "StartTimingVariant1",
+    "StartTimingVariant2",
+    "SubAsset",
+    "SyncCreativesError",
+    "SyncCreativesRequest",
+    "SyncCreativesResponse",
+    "SyncCreativesSuccess",
+    "Targeting",
+    "TaskStatus",
+    "TaskType",
+    "TasksGetRequest",
+    "TasksGetResponse",
+    "TasksListRequest",
+    "TasksListResponse",
+    "TextSubAsset",
+    "UpdateMediaBuyError",
+    "UpdateMediaBuyRequest",
+    "UpdateMediaBuyResponse",
+    "UpdateMediaBuySuccess",
+    "UrlDaastAsset",
+    "UrlPreviewRender",
+    "UrlVastAsset",
+    "VastAsset",
+    "WebhookPayload",
+]

adcp/utils/response_parser.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
-from typing import Any, TypeVar
+from typing import Any, TypeVar, Union, cast, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
@@ -13,6 +13,56 @@ logger = logging.getLogger(__name__)
 T = TypeVar("T", bound=BaseModel)
 
 
+def _validate_union_type(data: dict[str, Any], response_type: type[T]) -> T:
+    """
+    Validate data against a Union type by trying each variant.
+
+    Args:
+        data: Data to validate
+        response_type: Union type to validate against
+
+    Returns:
+        Validated model instance
+
+    Raises:
+        ValidationError: If data doesn't match any Union variant
+    """
+    # Check if this is a Union type (handles both typing.Union and types.UnionType)
+    origin = get_origin(response_type)
+
+    # In Python 3.10+, X | Y creates a types.UnionType, not typing.Union
+    # We need to check both the origin and the type itself
+    is_union = origin is Union or str(type(response_type).__name__) == "UnionType"
+
+    if is_union:
+        # Get union args - works for both typing.Union and types.UnionType
+        args = get_args(response_type)
+        if not args:  # types.UnionType case
+            # For types.UnionType, we need to access __args__ directly
+            args = getattr(response_type, "__args__", ())
+
+        errors = []
+        for variant in args:
+            try:
+                return cast(T, variant.model_validate(data))
+            except ValidationError as e:
+                errors.append((variant.__name__, e))
+                continue
+
+        # If we get here, none of the variants worked
+        error_msgs = [f"{name}: {str(e)}" for name, e in errors]
+        # Raise a ValueError instead of ValidationError for better error messages
+        raise ValueError(
+            f"Data doesn't match any Union variant. "
+            f"Attempted variants: {', '.join([e[0] for e in errors])}. "
+            f"Errors: {'; '.join(error_msgs)}"
+        )
+
+    # Not a Union type, use regular validation
+    # Cast is needed because response_type is typed as type[T] | Any
+    return cast(T, response_type.model_validate(data))  # type: ignore[redundant-cast]
+
+
 def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) -> T:
     """
     Parse MCP content array into structured response type.
@@ -48,8 +98,8 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
             try:
                 # Try parsing as JSON
                 data = json.loads(text)
-                # Validate against expected schema
-                return response_type.model_validate(data)
+                # Validate against expected schema (handles Union types)
+                return _validate_union_type(data, response_type)
             except json.JSONDecodeError:
                 # Not JSON, try next item
                 continue
@@ -61,7 +111,7 @@ def parse_mcp_content(content: list[dict[str, Any]], response_type: type[T]) ->
         elif item.get("type") == "resource":
             # Resource content might have structured data
             try:
-                return response_type.model_validate(item)
+                return _validate_union_type(item, response_type)
             except ValidationError:
                 # Try next item
                 continue
@@ -98,25 +148,24 @@ def parse_json_or_text(data: Any, response_type: type[T]) -> T:
     # If already a dict, try direct validation
     if isinstance(data, dict):
         try:
-            return response_type.model_validate(data)
+            return _validate_union_type(data, response_type)
         except ValidationError as e:
-            raise ValueError(
-                f"Response doesn't match expected schema {response_type.__name__}: {e}"
-            ) from e
+            # Get the type name, handling Union types
+            type_name = getattr(response_type, "__name__", str(response_type))
+            raise ValueError(f"Response doesn't match expected schema {type_name}: {e}") from e
 
     # If string, try JSON parsing
     if isinstance(data, str):
         try:
             parsed = json.loads(data)
-            return response_type.model_validate(parsed)
+            return _validate_union_type(parsed, response_type)
         except json.JSONDecodeError as e:
             raise ValueError(f"Response is not valid JSON: {e}") from e
         except ValidationError as e:
-            raise ValueError(
-                f"Response doesn't match expected schema {response_type.__name__}: {e}"
-            ) from e
+            # Get the type name, handling Union types
+            type_name = getattr(response_type, "__name__", str(response_type))
+            raise ValueError(f"Response doesn't match expected schema {type_name}: {e}") from e
 
     # Unsupported type
-    raise ValueError(
-        f"Cannot parse response of type {type(data).__name__} into {response_type.__name__}"
-    )
+    type_name = getattr(response_type, "__name__", str(response_type))
+    raise ValueError(f"Cannot parse response of type {type(data).__name__} into {type_name}")

{adcp-1.1.0.dist-info → adcp-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adcp
-Version: 1.1.0
+Version: 1.2.1
 Summary: Official Python client for the Ad Context Protocol (AdCP)
 Author-email: AdCP Community <maintainers@adcontextprotocol.org>
 License: Apache-2.0
@@ -59,6 +59,8 @@ AdCP operations are **distributed and asynchronous by default**. An agent might:
 pip install adcp
 ```
 
+> **Note**: This client requires Python 3.10 or later and supports both synchronous and asynchronous workflows.
+
 ## Quick Start: Distributed Operations
 
 ```python

{adcp-1.1.0.dist-info → adcp-1.2.1.dist-info}/RECORD

@@ -1,23 +1,23 @@
-adcp/__init__.py,sha256=p3emIEsC2FN_jcnHOP62BRPs6h4lgIhFselvAlTM0LI,2512
+adcp/__init__.py,sha256=3UpoB71XItkSZ_r1QuzE2GZIQsgVjt50ZawxQUO2-qs,6232
 adcp/__main__.py,sha256=Avy_C71rruh2lOuojvuXDj09tkFOaek74nJ-dbx25Sw,12838
-adcp/client.py,sha256=xs_sG7soRH1szk0S0rFu_6Ge4Ffe2aUdaTYnLmvteeo,27950
+adcp/client.py,sha256=co4tKdkjDrqZltCUPcYwVRr8LQfbBbG-DLjapLjcVuo,28246
 adcp/config.py,sha256=Vsy7ZPOI8G3fB_i5Nk-CHbC7wdasCUWuKlos0fwA0kY,2017
 adcp/exceptions.py,sha256=dNRMKV23DlkGKyB9Xmt6MtlhvDu1crjzD_en4nAEwDY,4399
 adcp/protocols/__init__.py,sha256=6UFwACQ0QadBUzy17wUROHqsJDp8ztPW2jzyl53Zh_g,262
 adcp/protocols/a2a.py,sha256=FHgc6G_eU2qD0vH7_RyS1eZvUFSb2j3-EsceoHPi384,12467
-adcp/protocols/base.py,sha256=CGqUilQv_ymhnfdowBV_HJhIxYUDM3sRO7ahW-kRB0M,5087
+adcp/protocols/base.py,sha256=vBHD23Fzl_CCk_Gy9nvSbBYopcJlYkYyzoz-rhI8wHg,5214
 adcp/protocols/mcp.py,sha256=eIk8snCinZm-ZjdarGVMt5nEYJ4_8POM9Fa5Mkw7xxU,15902
 adcp/types/__init__.py,sha256=3E_TJUXqQQFcjmSZZSPLwqBP3s_ijsH2LDeuOU-MP30,402
 adcp/types/core.py,sha256=RXkKCWCXS9BVJTNpe3Opm5O1I_LaQPMUuVwa-ipvS1Q,4839
-adcp/types/generated.py,sha256=j21CgpQExfd2gZTEnDUlVO3hvBmdn-4yBzgC86GUEnI,52485
+adcp/types/generated.py,sha256=Ig4ucbJzKRuHlwYzsqvMF9M3w2KghhQQqsXuOnBqVMM,74993
 adcp/types/tasks.py,sha256=Ae9TSwG2F7oWXTcl4TvLhAzinbQkHNGF1Pc0q8RMNNM,23424
 adcp/utils/__init__.py,sha256=uetvSJB19CjQbtwEYZiTnumJG11GsafQmXm5eR3hL7E,153
 adcp/utils/operation_id.py,sha256=wQX9Bb5epXzRq23xoeYPTqzu5yLuhshg7lKJZihcM2k,294
 adcp/utils/preview_cache.py,sha256=8_2qs5CgrHv1_WOnD4bs43VWueu-rcZRu5PZMQ_lyuE,17573
-adcp/utils/response_parser.py,sha256=NQTLlbvmnM_tE4B5w3oB1Wshny1p-Uh8IWbghlwoNJc,4057
-adcp-1.1.0.dist-info/licenses/LICENSE,sha256=PF39NR3Ae8PLgBhg3Uxw6ju7iGVIf8hfv9LRWQdii_U,629
-adcp-1.1.0.dist-info/METADATA,sha256=51wZBtGtYyiqVRSaZtPW3OqvQOcZurM-A2FUvqRgrV8,14455
-adcp-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-adcp-1.1.0.dist-info/entry_points.txt,sha256=DQKpcGsJX8DtVI_SGApQ7tNvqUB4zkTLaTAEpFgmi3U,44
-adcp-1.1.0.dist-info/top_level.txt,sha256=T1_NF0GefncFU9v_k56oDwKSJREyCqIM8lAwNZf0EOs,5
-adcp-1.1.0.dist-info/RECORD,,
+adcp/utils/response_parser.py,sha256=uPk2vIH-RYZmq7y3i8lC4HTMQ3FfKdlgXKTjgJ1955M,6253
+adcp-1.2.1.dist-info/licenses/LICENSE,sha256=PF39NR3Ae8PLgBhg3Uxw6ju7iGVIf8hfv9LRWQdii_U,629
+adcp-1.2.1.dist-info/METADATA,sha256=mDI2lRdXxOluUZ9vgRE3fyoGSnj8DQ8nqBU30Tuphjg,14568
+adcp-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+adcp-1.2.1.dist-info/entry_points.txt,sha256=DQKpcGsJX8DtVI_SGApQ7tNvqUB4zkTLaTAEpFgmi3U,44
+adcp-1.2.1.dist-info/top_level.txt,sha256=T1_NF0GefncFU9v_k56oDwKSJREyCqIM8lAwNZf0EOs,5
+adcp-1.2.1.dist-info/RECORD,,