@adcp/client 3.3.3 → 3.4.0

package/dist/lib/core/SingleAgentClient.js

@@ -62,7 +62,8 @@ class SingleAgentClient {
     executor;
     asyncHandler;
     normalizedAgent;
-    discoveredEndpoint; // Cache discovered endpoint
+    discoveredEndpoint; // Cache discovered MCP endpoint
+    canonicalBaseUrl; // Cache canonical base URL (from agent card or stripped /mcp)
     constructor(agent, config = {}) {
         this.agent = agent;
         this.config = config;
@@ -89,6 +90,7 @@ class SingleAgentClient {
      *
      * If the agent needs discovery, perform it now and cache the result.
      * Returns the agent config with the discovered endpoint.
+     * Also computes the canonical base URL by stripping /mcp suffix.
      */
     async ensureEndpointDiscovered() {
         const needsDiscovery = this.normalizedAgent._needsDiscovery;
@@ -104,11 +106,101 @@ class SingleAgentClient {
         }
         // Perform discovery
         this.discoveredEndpoint = await this.discoverMCPEndpoint(this.normalizedAgent.agent_uri);
+        // Compute canonical base URL by stripping /mcp suffix
+        this.canonicalBaseUrl = this.computeBaseUrl(this.discoveredEndpoint);
         return {
             ...this.normalizedAgent,
             agent_uri: this.discoveredEndpoint,
         };
     }
+    /**
+     * Ensure A2A canonical URL is resolved (lazy initialization)
+     *
+     * Fetches the agent card and extracts the canonical URL.
+     * Returns the agent config with the canonical URL.
+     */
+    async ensureCanonicalUrlResolved() {
+        const needsCanonicalUrl = this.normalizedAgent._needsCanonicalUrl;
+        if (!needsCanonicalUrl) {
+            return this.normalizedAgent;
+        }
+        // Already resolved? Use cached value
+        if (this.canonicalBaseUrl) {
+            return {
+                ...this.normalizedAgent,
+                agent_uri: this.canonicalBaseUrl,
+            };
+        }
+        // Fetch agent card to get canonical URL
+        const canonicalUrl = await this.fetchA2ACanonicalUrl(this.normalizedAgent.agent_uri);
+        this.canonicalBaseUrl = canonicalUrl;
+        return {
+            ...this.normalizedAgent,
+            agent_uri: canonicalUrl,
+        };
+    }
+    /**
+     * Fetch the canonical URL from an A2A agent card
+     */
+    async fetchA2ACanonicalUrl(agentUri) {
+        const clientModule = require('@a2a-js/sdk/client');
+        const A2AClient = clientModule.A2AClient;
+        const authToken = this.normalizedAgent.auth_token_env;
+        const fetchImpl = authToken
+            ? async (url, options) => {
+                const headers = {
+                    ...options?.headers,
+                    Authorization: `Bearer ${authToken}`,
+                    'x-adcp-auth': authToken,
+                };
+                return fetch(url, { ...options, headers });
+            }
+            : undefined;
+        // Construct agent card URL
+        const cardUrl = agentUri.endsWith('/.well-known/agent-card.json')
+            ? agentUri
+            : agentUri.replace(/\/$/, '') + '/.well-known/agent-card.json';
+        const client = await A2AClient.fromCardUrl(cardUrl, fetchImpl ? { fetchImpl } : {});
+        const agentCard = client.agentCardPromise ? await client.agentCardPromise : client.agentCard;
+        // Use the canonical URL from the agent card, falling back to computed base URL
+        if (agentCard?.url) {
+            return agentCard.url;
+        }
+        // Fallback: strip .well-known/agent-card.json if present
+        return this.computeBaseUrl(agentUri);
+    }
+    /**
+     * Compute base URL by stripping protocol-specific suffixes
+     *
+     * - Strips /mcp or /mcp/ suffix for MCP endpoints
+     * - Strips /.well-known/agent-card.json for A2A discovery URLs
+     * - Strips trailing slash for consistency
+     */
+    computeBaseUrl(url) {
+        let baseUrl = url;
+        // Strip /.well-known/agent-card.json
+        if (baseUrl.match(/\/\.well-known\/agent-card\.json$/i)) {
+            baseUrl = baseUrl.replace(/\/\.well-known\/agent-card\.json$/i, '');
+        }
+        // Strip /mcp or /mcp/
+        if (baseUrl.match(/\/mcp\/?$/i)) {
+            baseUrl = baseUrl.replace(/\/mcp\/?$/i, '');
+        }
+        // Strip trailing slash for consistency
+        baseUrl = baseUrl.replace(/\/$/, '');
+        return baseUrl;
+    }
+    /**
+     * Check if URL is a .well-known/agent-card.json URL
+     *
+     * These URLs are A2A agent card discovery URLs and should use A2A protocol.
+     * Only matches when .well-known is at the root path (not in a subdirectory).
+     */
+    isWellKnownAgentCardUrl(url) {
+        // Match: https://example.com/.well-known/agent-card.json
+        // Don't match: https://example.com/api/.well-known/agent-card.json
+        return /^https?:\/\/[^/]+\/\.well-known\/agent-card\.json$/i.test(url);
+    }
     /**
      * Discover MCP endpoint by testing the provided path, then trying variants
      *
@@ -180,35 +272,56 @@ class SingleAgentClient {
             `None responded to MCP protocol.`);
     }
     /**
-     * Normalize agent config - mark all MCP agents for discovery
+     * Normalize agent config
      *
-     * We always test the endpoint they give us, and if it doesn't work,
-     * we try adding /mcp. Simple.
+     * - If URL is a .well-known/agent-card.json URL, switch to A2A protocol
+     *   (these are A2A discovery URLs, not MCP endpoints)
+     * - A2A agents are marked for canonical URL resolution (from agent card)
+     * - MCP agents are marked for endpoint discovery
      */
     normalizeAgentConfig(agent) {
+        // If URL is a well-known agent card URL, use A2A protocol regardless of what was specified
+        // Mark for canonical URL resolution - we'll fetch the agent card and use its url field
+        if (this.isWellKnownAgentCardUrl(agent.agent_uri)) {
+            return {
+                ...agent,
+                protocol: 'a2a',
+                _needsCanonicalUrl: true,
+            };
+        }
+        if (agent.protocol === 'a2a') {
+            // A2A agents need canonical URL resolution from agent card
+            return {
+                ...agent,
+                _needsCanonicalUrl: true,
+            };
+        }
         if (agent.protocol !== 'mcp') {
             return agent;
         }
-        // Mark for discovery - we'll test their path, then try adding /mcp
+        // MCP agents need endpoint discovery - we'll test their path, then try adding /mcp
         return {
             ...agent,
             _needsDiscovery: true,
         };
     }
     /**
-     * Handle webhook from agent (async task completion)
+     * Handle webhook from agent (async task status updates and completions)
      *
-     * Accepts either:
-     * 1. Standard WebhookPayload format (operation_id, task_type, result, etc.)
-     * 2. Raw A2A task payload (artifacts, status, contextId, etc.) - will be transformed
+     * Accepts webhook payloads from both MCP and A2A protocols:
+     * 1. MCP: MCPWebhookPayload envelope with AdCP data in .result field
+     * 2. A2A: Native Task/TaskStatusUpdateEvent with AdCP data in either:
+     *    - status.message.parts[].data (for status updates)
+     *    - artifacts (for task completion, per A2A spec)
      *
-     * For A2A payloads, extracts the ADCP response from artifacts[0].parts[].data
-     * so handlers receive the unwrapped response, not the raw protocol structure.
+     * The method normalizes both formats so handlers receive the unwrapped
+     * AdCP response data (AdCPAsyncResponseData), not the raw protocol structure.
      *
-     * @param payload - Webhook payload from agent (WebhookPayload or raw A2A task)
+     * @param payload - Protocol-specific webhook payload (MCPWebhookPayload | Task | TaskStatusUpdateEvent)
+     * @param taskType - Task type (e.g create_media_buy) from url param or url part of the webhook delivery
+     * @param operationId - Operation id (e.g used for client app to track the operation) from the param or url part of the webhook delivery
      * @param signature - X-ADCP-Signature header (format: "sha256=...")
      * @param timestamp - X-ADCP-Timestamp header (Unix timestamp)
-     * @param taskType - Task type override (useful when not in payload, e.g., from URL path)
      * @returns Whether webhook was handled successfully
      *
      * @example
@@ -226,7 +339,7 @@ class SingleAgentClient {
      * });
      * ```
      */
-    async handleWebhook(payload, signature, timestamp, taskType) {
+    async handleWebhook(payload, taskType, operationId, signature, timestamp) {
         // Verify signature if secret is configured
         if (this.config.webhookSecret) {
             if (!signature || !timestamp) {
@@ -236,78 +349,124 @@ class SingleAgentClient {
             if (!isValid) {
                 throw new Error('Invalid webhook signature or timestamp too old');
             }
+            console.log('[ADCP Client]: Webhook signature is valid');
         }
-        // Transform raw A2A task payload to WebhookPayload format
-        const normalizedPayload = this.normalizeWebhookPayload(payload, taskType);
-        // Emit activity
-        await this.config.onActivity?.({
-            type: 'webhook_received',
+        // Transform raw protocol payload to normalized format
+        const normalizedPayload = this.normalizeWebhookPayload(payload, taskType, operationId);
+        const metadata = {
             operation_id: normalizedPayload.operation_id,
-            agent_id: this.agent.id,
             context_id: normalizedPayload.context_id,
             task_id: normalizedPayload.task_id,
+            agent_id: this.agent.id,
             task_type: normalizedPayload.task_type,
             status: normalizedPayload.status,
-            payload: normalizedPayload.result,
+            message: normalizedPayload.message,
             timestamp: normalizedPayload.timestamp || new Date().toISOString(),
+        };
+        // Emit activity
+        await this.config.onActivity?.({
+            type: 'webhook_received',
+            operation_id: metadata.operation_id,
+            agent_id: metadata.agent_id,
+            context_id: metadata.context_id,
+            task_id: metadata.task_id,
+            task_type: metadata.task_type,
+            status: metadata.status,
+            payload: normalizedPayload.result,
+            timestamp: metadata.timestamp,
         });
         // Handle through async handler if configured
         if (this.asyncHandler) {
-            await this.asyncHandler.handleWebhook(normalizedPayload, this.agent.id);
+            await this.asyncHandler.handleWebhook({ result: normalizedPayload.result, metadata });
             return true;
         }
         return false;
     }
     /**
-     * Normalize webhook payload - transform raw A2A task payload to WebhookPayload format
+     * Normalize webhook payload - handles both MCP and A2A webhook formats
      *
-     * Detects if payload is a raw A2A task (has artifacts, kind: 'task') and extracts
-     * the ADCP response from artifacts[0].parts[].data where kind === 'data'.
+     * MCP: Uses MCPWebhookPayload envelope with AdCP data in .result field
+     * A2A: Uses native Task/TaskStatusUpdateEvent messages with AdCP data in either:
+     *      - status.message.parts[].data (for status updates)
+     *      - artifacts (for task completion responses, per A2A spec)
      *
-     * @param payload - Raw webhook payload (could be WebhookPayload or A2A task)
-     * @param taskType - Task type override (useful when from URL path)
-     * @returns Normalized WebhookPayload with extracted ADCP response
+     * @param payload - Protocol-specific webhook payload (MCPWebhookPayload | Task | TaskStatusUpdateEvent)
+     * @param taskType - Task type override
+     * @param operationId - Operation id
+     * @returns Normalized webhook payload with extracted AdCP response
      */
-    normalizeWebhookPayload(payload, taskType) {
-        // Check if this is a raw A2A task payload (has artifacts and kind: 'task')
-        const isA2ATaskPayload = payload.artifacts && (payload.kind === 'task' || payload.status?.state);
-        if (!isA2ATaskPayload) {
-            // Already in WebhookPayload format or close enough
-            return payload;
+    normalizeWebhookPayload(payload, taskType, operationId) {
+        // 1. Check for MCP Webhook Payload (has task_id, status, task_type fields)
+        if ('task_id' in payload && 'task_type' in payload && 'status' in payload) {
+            const mcpPayload = payload;
+            return {
+                operation_id: operationId || 'unknown',
+                context_id: mcpPayload.context_id,
+                task_id: mcpPayload.task_id,
+                task_type: taskType,
+                status: mcpPayload.status,
+                result: mcpPayload.result,
+                message: mcpPayload.message,
+                timestamp: mcpPayload.timestamp,
+            };
         }
-        // Extract status from A2A task
-        const a2aStatus = payload.status?.state || 'unknown';
-        // For completed tasks, extract the ADCP response from artifacts
-        let result = undefined;
-        if (a2aStatus === 'completed' && payload.artifacts?.length > 0) {
-            try {
-                // Use the response unwrapper to extract ADCP data from A2A artifacts
-                // Wrap in the format unwrapProtocolResponse expects
-                result = (0, response_unwrapper_1.unwrapProtocolResponse)({ result: payload }, taskType, 'a2a');
+        // 2. Check for A2A Task or TaskStatusUpdateEvent
+        if ('kind' in payload && (payload.kind === 'task' || payload.kind === 'status-update')) {
+            const a2aPayload = payload;
+            const a2aStatus = a2aPayload.status?.state || 'unknown';
+            let result = undefined;
+            // Try to extract data from status.message.parts first (for status updates)
+            const parts = a2aPayload.status?.message?.parts;
+            if (parts && Array.isArray(parts)) {
+                const dataPart = parts.find(p => 'data' in p && p.kind === 'data');
+                if (dataPart && 'data' in dataPart) {
+                    result = dataPart.data;
+                }
             }
-            catch (error) {
-                // If unwrapping fails, pass the raw artifacts as result
-                // The handler can deal with it
-                console.warn('Failed to unwrap A2A webhook payload:', error);
-                result = payload.artifacts;
+            // If not found in parts, check artifacts (standard A2A task output location)
+            if (!result && 'artifacts' in a2aPayload && a2aPayload.artifacts && a2aPayload.artifacts.length > 0) {
+                try {
+                    // Try to unwrap artifacts for all statuses
+                    result = (0, response_unwrapper_1.unwrapProtocolResponse)({ result: a2aPayload }, taskType, 'a2a');
+                }
+                catch (error) {
+                    console.warn('Failed to unwrap A2A webhook payload:', error);
+                    // Fallback: pass raw artifacts so handler has something to work with
+                    result = a2aPayload.artifacts;
+                }
             }
+            // Extract message part from status.message.parts (A2A Message structure)
+            let message = undefined;
+            if (a2aPayload.status?.message?.parts) {
+                const textParts = a2aPayload.status.message.parts
+                    .filter(p => p.kind === 'text' && 'text' in p)
+                    .map(p => ('text' in p ? p.text : ''));
+                if (textParts.length > 0) {
+                    message = textParts.join(' ');
+                }
+            }
+            // Get task_id ensuring it's a string
+            let taskId = 'unknown';
+            if ('id' in a2aPayload && a2aPayload.id) {
+                taskId = String(a2aPayload.id);
+            }
+            else if ('taskId' in a2aPayload && a2aPayload.taskId) {
+                taskId = String(a2aPayload.taskId);
+            }
+            return {
+                operation_id: operationId,
+                context_id: 'contextId' in a2aPayload ? a2aPayload.contextId : undefined,
+                task_id: taskId,
+                task_type: taskType,
+                status: a2aStatus,
+                result,
+                message: message,
+                timestamp: a2aPayload.status?.timestamp || new Date().toISOString(),
+            };
         }
-        else if (payload.artifacts?.length > 0) {
-            // For non-completed tasks (working, input-required), just pass artifacts
-            result = payload.artifacts;
-        }
-        // Build normalized WebhookPayload
-        return {
-            operation_id: payload.metadata?.operation_id || payload.id || 'unknown',
-            context_id: payload.contextId || payload.metadata?.adcp_context?.buyer_ref,
-            task_id: payload.id,
-            task_type: payload?.task_type || taskType || 'unknown',
-            status: a2aStatus,
-            result,
-            error: payload.status?.message?.message || payload.error,
-            message: payload.status?.message?.message,
-            timestamp: payload.status?.timestamp || new Date().toISOString(),
-        };
+        // 3. Unknown payload format
+        throw new Error('Unsupported webhook payload format. Expected MCPWebhookPayload, Task, or TaskStatusUpdateEvent. ' +
+            `Received: ${JSON.stringify(payload).substring(0, 200)}`);
     }
     /**
      * Generate webhook URL using macro substitution
@@ -501,23 +660,34 @@ class SingleAgentClient {
      * @param options - Task execution options
      */
     async createMediaBuy(params, inputHandler, options) {
-        // Auto-inject reporting_webhook if supported and not provided by caller
+        // Merge library defaults with consumer-provided reporting_webhook config
+        // Library provides url/auth/frequency defaults, consumer can override any field
         // Generates a media_buy_delivery webhook URL using operation_id pattern: delivery_report_{agent_id}_{YYYY-MM}
-        if (!params?.reporting_webhook && this.config.webhookUrlTemplate) {
+        if (this.config.webhookUrlTemplate) {
             const now = new Date();
             const year = now.getUTCFullYear();
             const month = String(now.getUTCMonth() + 1).padStart(2, '0');
             const operationId = `delivery_report_${this.agent.id}_${year}-${month}`;
             const deliveryWebhookUrl = this.getWebhookUrl('media_buy_delivery', operationId);
+            // Library defaults
+            const libraryDefaults = {
+                url: deliveryWebhookUrl,
+                authentication: {
+                    schemes: ['HMAC-SHA256'],
+                    credentials: this.config.webhookSecret || 'placeholder_secret_min_32_characters_required',
+                },
+                reporting_frequency: (this.config.reportingWebhookFrequency || 'daily'),
+            };
+            // Deep merge: consumer overrides library defaults
             params = {
                 ...params,
                 reporting_webhook: {
-                    url: deliveryWebhookUrl,
+                    ...libraryDefaults,
+                    ...params.reporting_webhook,
                     authentication: {
-                        schemes: ['HMAC-SHA256'],
-                        credentials: this.config.webhookSecret || 'placeholder_secret_min_32_characters_required',
+                        ...libraryDefaults.authentication,
+                        ...params.reporting_webhook?.authentication,
                     },
-                    reporting_frequency: this.config.reportingWebhookFrequency || 'daily',
                 },
             };
         }
@@ -702,10 +872,39 @@ class SingleAgentClient {
     }
     // ====== AGENT INFORMATION ======
     /**
-     * Get the agent configuration
+     * Get the agent configuration with normalized protocol
+     *
+     * Returns the agent config with:
+     * - Protocol normalized (e.g., .well-known URLs switch to A2A)
+     * - If canonical URL has been resolved, agent_uri will be the canonical URL
+     *
+     * For guaranteed canonical URL, use getResolvedAgent() instead.
      */
     getAgent() {
-        return { ...this.agent };
+        // If we have resolved the canonical URL, return config with it
+        if (this.canonicalBaseUrl) {
+            const { _needsDiscovery, _needsCanonicalUrl, ...cleanAgent } = this.normalizedAgent;
+            return {
+                ...cleanAgent,
+                agent_uri: this.canonicalBaseUrl,
+            };
+        }
+        // Return normalized agent without internal flags
+        const { _needsDiscovery, _needsCanonicalUrl, ...cleanAgent } = this.normalizedAgent;
+        return { ...cleanAgent };
+    }
+    /**
+     * Get the fully resolved agent configuration
+     *
+     * This async method ensures the agent config has the canonical URL resolved:
+     * - For A2A: Fetches the agent card and uses its 'url' field
+     * - For MCP: Performs endpoint discovery
+     *
+     * @returns Promise resolving to agent config with canonical URL
+     */
+    async getResolvedAgent() {
+        await this.resolveCanonicalUrl();
+        return this.getAgent();
     }
     /**
      * Get the agent ID
@@ -720,10 +919,99 @@ class SingleAgentClient {
         return this.agent.name;
     }
     /**
-     * Get the agent protocol
+     * Get the agent protocol (may be normalized from original config)
      */
     getProtocol() {
-        return this.agent.protocol;
+        return this.normalizedAgent.protocol;
+    }
+    /**
+     * Get the canonical base URL for this agent
+     *
+     * Returns the canonical URL if already resolved, or computes it synchronously
+     * from the configured URL. For the most accurate canonical URL (especially for A2A
+     * where the agent card contains the authoritative URL), use resolveCanonicalUrl() first.
+     *
+     * The canonical URL is:
+     * - For A2A: The 'url' field from the agent card (if resolved), or base URL with
+     *   /.well-known/agent-card.json stripped
+     * - For MCP: The discovered endpoint with /mcp stripped
+     *
+     * @returns The canonical base URL (synchronous, may not be fully resolved)
+     */
+    getCanonicalUrl() {
+        // Return cached canonical URL if available
+        if (this.canonicalBaseUrl) {
+            return this.canonicalBaseUrl;
+        }
+        // Compute from configured URL (best effort without network call)
+        return this.computeBaseUrl(this.normalizedAgent.agent_uri);
+    }
+    /**
+     * Resolve and return the canonical base URL for this agent
+     *
+     * This async method ensures the canonical URL is properly resolved:
+     * - For A2A: Fetches the agent card and uses its 'url' field
+     * - For MCP: Performs endpoint discovery and strips /mcp suffix
+     *
+     * The result is cached, so subsequent calls are fast.
+     *
+     * @returns Promise resolving to the canonical base URL
+     */
+    async resolveCanonicalUrl() {
+        if (this.canonicalBaseUrl) {
+            return this.canonicalBaseUrl;
+        }
+        if (this.normalizedAgent.protocol === 'a2a') {
+            await this.ensureCanonicalUrlResolved();
+        }
+        else if (this.normalizedAgent.protocol === 'mcp') {
+            await this.ensureEndpointDiscovered();
+        }
+        return this.canonicalBaseUrl || this.computeBaseUrl(this.normalizedAgent.agent_uri);
+    }
+    /**
+     * Check if this agent is the same as another agent
+     *
+     * Compares agents by their canonical base URLs. Two agents are considered
+     * the same if they have the same canonical URL, regardless of:
+     * - Protocol (MCP vs A2A)
+     * - URL format (with/without /mcp, with/without /.well-known/agent-card.json)
+     * - Trailing slashes
+     *
+     * @param other - Another agent configuration or SingleAgentClient to compare
+     * @returns true if agents have the same canonical URL
+     */
+    isSameAgent(other) {
+        const thisUrl = this.getCanonicalUrl().toLowerCase();
+        let otherUrl;
+        if (other instanceof SingleAgentClient) {
+            otherUrl = other.getCanonicalUrl().toLowerCase();
+        }
+        else {
+            otherUrl = this.computeBaseUrl(other.agent_uri).toLowerCase();
+        }
+        return thisUrl === otherUrl;
+    }
+    /**
+     * Async version of isSameAgent that resolves canonical URLs first
+     *
+     * This provides more accurate comparison for A2A agents since it fetches
+     * the agent card to get the authoritative canonical URL.
+     *
+     * @param other - Another agent configuration or SingleAgentClient to compare
+     * @returns Promise resolving to true if agents have the same canonical URL
+     */
+    async isSameAgentResolved(other) {
+        const thisUrl = (await this.resolveCanonicalUrl()).toLowerCase();
+        let otherUrl;
+        if (other instanceof SingleAgentClient) {
+            otherUrl = (await other.resolveCanonicalUrl()).toLowerCase();
+        }
+        else {
+            // For raw AgentConfig, we can only compute from the URL
+            otherUrl = this.computeBaseUrl(other.agent_uri).toLowerCase();
+        }
+        return thisUrl === otherUrl;
     }
     /**
      * Get active tasks for this agent
@@ -832,7 +1120,7 @@ class SingleAgentClient {
      * ```
      */
     async getAgentInfo() {
-        if (this.agent.protocol === 'mcp') {
+        if (this.normalizedAgent.protocol === 'mcp') {
             // Discover endpoint if needed
             const agent = await this.ensureEndpointDiscovered();
             // Use MCP SDK to list tools
@@ -842,7 +1130,7 @@ class SingleAgentClient {
                 name: 'AdCP-Client',
                 version: '1.0.0',
             });
-            const authToken = this.agent.auth_token_env;
+            const authToken = this.normalizedAgent.auth_token_env;
             const customFetch = authToken
                 ? async (input, init) => {
                     // IMPORTANT: Must preserve SDK's default headers (especially Accept header)
@@ -891,18 +1179,18 @@ class SingleAgentClient {
                 parameters: tool.inputSchema?.properties ? Object.keys(tool.inputSchema.properties) : [],
             }));
             return {
-                name: this.agent.name,
+                name: this.normalizedAgent.name,
                 description: undefined,
-                protocol: this.agent.protocol,
+                protocol: this.normalizedAgent.protocol,
                 url: agent.agent_uri,
                 tools,
             };
         }
-        else if (this.agent.protocol === 'a2a') {
+        else if (this.normalizedAgent.protocol === 'a2a') {
             // Use A2A SDK to get agent card
             const clientModule = require('@a2a-js/sdk/client');
             const A2AClient = clientModule.A2AClient;
-            const authToken = this.agent.auth_token_env;
+            const authToken = this.normalizedAgent.auth_token_env;
             const fetchImpl = authToken
                 ? async (url, options) => {
                     const headers = {
@@ -927,14 +1215,14 @@ class SingleAgentClient {
                 }))
                 : [];
             return {
-                name: agentCard?.displayName || agentCard?.name || this.agent.name,
+                name: agentCard?.displayName || agentCard?.name || this.normalizedAgent.name,
                 description: agentCard?.description,
-                protocol: this.agent.protocol,
+                protocol: this.normalizedAgent.protocol,
                 url: this.normalizedAgent.agent_uri,
                 tools,
             };
         }
-        throw new Error(`Unsupported protocol: ${this.agent.protocol}`);
+        throw new Error(`Unsupported protocol: ${this.normalizedAgent.protocol}`);
     }
     // ====== STATIC HELPER METHODS ======
     /**