proofscan 0.10.61 → 0.11.0

package/dist/a2a/client.js

@@ -0,0 +1,854 @@
+/**
+ * A2A Client
+ *
+ * Client for sending messages to A2A agents via JSON-RPC 2.0.
+ * Implements message/send, tasks/get, tasks/list, and tasks/cancel operations.
+ *
+ * Phase 4 - Client Implementation
+ * Phase 2 - Task Management (getTask, listTasks, cancelTask)
+ * Phase 2.4 - Task DB event recording
+ */
+import { randomUUID } from 'crypto';
+import { isPrivateUrl } from './agent-card.js';
+// Maximum response size (1MB) to prevent DoS
+const MAX_RESPONSE_SIZE = 1024 * 1024;
+// ===== A2A Client =====
+/**
+ * A2A Client for sending messages to agents
+ */
+export class A2AClient {
+    baseUrl;
+    defaultHeaders;
+    agentCard;
+    allowLocal;
+    eventsStore; // Phase 2.4: Optional events store for task event recording
+    constructor(agentCard, options) {
+        this.agentCard = agentCard;
+        this.baseUrl = agentCard.url.replace(/\/$/, '');
+        this.allowLocal = options?.allowLocal ?? false;
+        this.eventsStore = options?.eventsStore; // Phase 2.4
+        // SSRF protection: Block private URLs in constructor
+        if (isPrivateUrl(this.baseUrl) && !this.allowLocal) {
+            throw new Error('Private or local URLs are not allowed');
+        }
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            ...options?.headers,
+        };
+    }
+    /**
+     * Get EventsStore instance (Phase 2.4)
+     * @private
+     */
+    getEventsStore() {
+        return this.eventsStore;
+    }
+    /**
+     * Send a message to the agent
+     * POST /message/send (JSON-RPC 2.0)
+     */
+    async sendMessage(message, options = {}) {
+        const { timeout = 30000, headers = {}, blocking = false } = options;
+        // Convert string message to A2AMessage with unique messageId
+        const messageId = randomUUID();
+        const a2aMessage = typeof message === 'string'
+            ? { role: 'user', parts: [{ text: message }], messageId }
+            : { ...message, messageId: message.messageId ?? messageId };
+        // Build JSON-RPC request with unique ID
+        const requestId = randomUUID();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'message/send',
+            params: {
+                message: a2aMessage,
+                configuration: blocking ? { blocking: true } : undefined,
+            },
+        };
+        // Set up abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            // SSRF protection (defense-in-depth): Double-check URL even though constructor validates
+            if (isPrivateUrl(this.baseUrl) && !this.allowLocal) {
+                return {
+                    ok: false,
+                    error: 'Private or local URLs are not allowed',
+                };
+            }
+            const response = await fetch(this.baseUrl, {
+                method: 'POST',
+                headers: { ...this.defaultHeaders, ...headers },
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            // Validate Content-Type
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('application/json')) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Expected JSON response, got ${contentType || 'unknown'}`,
+                };
+            }
+            // Check Content-Length for size limit
+            const contentLength = response.headers.get('content-length');
+            if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Response too large: ${contentLength} bytes (max ${MAX_RESPONSE_SIZE})`,
+                };
+            }
+            const responseText = await response.text();
+            // Validate actual response size
+            if (responseText.length > MAX_RESPONSE_SIZE) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Response too large: ${responseText.length} bytes (max ${MAX_RESPONSE_SIZE})`,
+                };
+            }
+            let responseData;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Invalid JSON response: ${responseText.slice(0, 200)}`,
+                };
+            }
+            // Handle JSON-RPC error
+            if (responseData.error) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `${responseData.error.code}: ${responseData.error.message}`,
+                };
+            }
+            // Parse result - can be Task or Message
+            if (!responseData.result) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: 'No result in response',
+                };
+            }
+            const result = responseData.result;
+            // Check if result is a Task (has 'status' field)
+            if ('status' in result) {
+                const task = this.parseTask(result);
+                return { ok: true, task };
+            }
+            // Check if result is a Message (has 'role' field)
+            if ('role' in result) {
+                const msg = this.parseMessage(result);
+                return { ok: true, message: msg };
+            }
+            return {
+                ok: false,
+                statusCode: response.status,
+                error: `Unknown response type: ${JSON.stringify(result).slice(0, 200)}`,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    return {
+                        ok: false,
+                        error: `Request timeout after ${timeout}ms`,
+                    };
+                }
+                return {
+                    ok: false,
+                    error: error.message,
+                };
+            }
+            return {
+                ok: false,
+                error: String(error),
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Get task by ID (Phase 2 - A2A Protocol Compliant)
+     * POST /a2a (JSON-RPC 2.0)
+     *
+     * @param taskId - The task ID to retrieve
+     * @param options - Optional: historyLength, headers, timeout
+     * @returns Promise<GetTaskResult> with task or error
+     */
+    async getTask(taskId, options = {}) {
+        const { historyLength, headers = {}, timeout = 30000 } = options;
+        const requestId = randomUUID();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'tasks/get',
+            params: {
+                id: taskId,
+                ...(historyLength !== undefined && { historyLength }),
+            },
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(this.baseUrl, {
+                method: 'POST',
+                headers: { ...this.defaultHeaders, ...headers },
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('application/json')) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Expected JSON response, got ${contentType || 'unknown'}`,
+                };
+            }
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_SIZE) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Response too large: ${responseText.length} bytes (max ${MAX_RESPONSE_SIZE})`,
+                };
+            }
+            let responseData;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Invalid JSON response: ${responseText.slice(0, 200)}`,
+                };
+            }
+            if (responseData.error) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `${responseData.error.code}: ${responseData.error.message}`,
+                };
+            }
+            if (!responseData.result) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: 'No result in response',
+                };
+            }
+            const task = this.parseTask(responseData.result);
+            return { ok: true, task };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    return {
+                        ok: false,
+                        error: `Request timeout after ${timeout}ms`,
+                    };
+                }
+                return {
+                    ok: false,
+                    error: error.message,
+                };
+            }
+            return {
+                ok: false,
+                error: String(error),
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * List tasks with optional filters (Phase 2)
+     * POST /a2a (JSON-RPC 2.0)
+     *
+     * @param params - Optional: contextId, status, pageSize, pageToken, includeArtifacts
+     * @returns Promise<ListTasksResult> with tasks list or error
+     */
+    async listTasks(params) {
+        const requestId = randomUUID();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'tasks/list',
+            params: (params || {}),
+        };
+        try {
+            const response = await fetch(this.baseUrl, {
+                method: 'POST',
+                headers: this.defaultHeaders,
+                body: JSON.stringify(request),
+            });
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('application/json')) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Expected JSON response, got ${contentType || 'unknown'}`,
+                };
+            }
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_SIZE) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Response too large: ${responseText.length} bytes (max ${MAX_RESPONSE_SIZE})`,
+                };
+            }
+            let responseData;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Invalid JSON response: ${responseText.slice(0, 200)}`,
+                };
+            }
+            if (responseData.error) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `${responseData.error.code}: ${responseData.error.message}`,
+                };
+            }
+            if (!responseData.result) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: 'No result in response',
+                };
+            }
+            const result = responseData.result;
+            const tasks = [];
+            if (Array.isArray(result.tasks)) {
+                for (const taskData of result.tasks) {
+                    tasks.push(this.parseTask(taskData));
+                }
+            }
+            const listResponse = {
+                tasks,
+                nextPageToken: result.nextPageToken ? String(result.nextPageToken) : '',
+                pageSize: typeof result.pageSize === 'number' ? result.pageSize : 50,
+                totalSize: typeof result.totalSize === 'number' ? result.totalSize : undefined,
+            };
+            return { ok: true, response: listResponse };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return {
+                    ok: false,
+                    error: error.message,
+                };
+            }
+            return {
+                ok: false,
+                error: String(error),
+            };
+        }
+    }
+    /**
+     * Cancel a task (Phase 2 - A2A Protocol Compliant)
+     * POST /a2a (JSON-RPC 2.0)
+     *
+     * @param taskId - The task ID to cancel
+     * @returns Promise<CancelTaskResult> with canceled task or error
+     */
+    async cancelTask(taskId) {
+        const requestId = randomUUID();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'tasks/cancel',
+            params: {
+                id: taskId,
+            },
+        };
+        try {
+            const response = await fetch(this.baseUrl, {
+                method: 'POST',
+                headers: this.defaultHeaders,
+                body: JSON.stringify(request),
+            });
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('application/json')) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Expected JSON response, got ${contentType || 'unknown'}`,
+                };
+            }
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_SIZE) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Response too large: ${responseText.length} bytes (max ${MAX_RESPONSE_SIZE})`,
+                };
+            }
+            let responseData;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `Invalid JSON response: ${responseText.slice(0, 200)}`,
+                };
+            }
+            if (responseData.error) {
+                return {
+                    ok: false,
+                    statusCode: response.status,
+                    error: `${responseData.error.code}: ${responseData.error.message}`,
+                };
+            }
+            // Parse the canceled task from response
+            if (responseData.result) {
+                const task = this.parseTask(responseData.result);
+                return { ok: true, task };
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                return {
+                    ok: false,
+                    error: error.message,
+                };
+            }
+            return {
+                ok: false,
+                error: String(error),
+            };
+        }
+    }
+    /**
+     * Stream message to agent
+     * POST /message/stream (JSON-RPC 2.0 + SSE response)
+     */
+    async streamMessage(message, options = {}) {
+        const { timeout = 60000, headers = {}, onStatus, onArtifact, onMessage, onTask, onError, signal, } = options;
+        // Build JSON-RPC request
+        const a2aMessage = typeof message === 'string'
+            ? { role: 'user', parts: [{ text: message }] }
+            : message;
+        const requestId = randomUUID();
+        const request = {
+            jsonrpc: '2.0',
+            id: requestId,
+            method: 'message/stream',
+            params: { message: a2aMessage },
+        };
+        // Abort controller for timeout
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        // Combine with external signal if provided
+        if (signal) {
+            signal.addEventListener('abort', () => controller.abort());
+        }
+        try {
+            // SSRF protection (defense-in-depth)
+            if (isPrivateUrl(this.baseUrl) && !this.allowLocal) {
+                return {
+                    ok: false,
+                    error: 'Private or local URLs are not allowed',
+                };
+            }
+            const response = await fetch(`${this.baseUrl}/message/stream`, {
+                method: 'POST',
+                headers: { ...this.defaultHeaders, ...headers },
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                return {
+                    ok: false,
+                    error: `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            const contentType = response.headers.get('content-type');
+            if (!contentType?.includes('text/event-stream')) {
+                return {
+                    ok: false,
+                    error: `Expected SSE, got ${contentType}`,
+                };
+            }
+            // Process SSE stream
+            const reader = response.body?.getReader();
+            if (!reader) {
+                return { ok: false, error: 'No response body' };
+            }
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let taskId;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep incomplete line
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const json = JSON.parse(data);
+                            const event = this.parseStreamEvent(json);
+                            if (event) {
+                                switch (event.type) {
+                                    case 'status':
+                                        taskId = event.event.taskId;
+                                        onStatus?.(event.event);
+                                        if (event.event.final) {
+                                            return { ok: true, taskId };
+                                        }
+                                        break;
+                                    case 'artifact':
+                                        onArtifact?.(event.event);
+                                        break;
+                                    case 'message':
+                                        onMessage?.(event.message);
+                                        break;
+                                    case 'task':
+                                        taskId = event.task.id;
+                                        onTask?.(event.task);
+                                        break;
+                                }
+                            }
+                        }
+                        catch (e) {
+                            onError?.(`Parse error: ${e}`);
+                        }
+                    }
+                }
+            }
+            return { ok: true, taskId };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                return { ok: false, error: `Timeout after ${timeout}ms` };
+            }
+            return { ok: false, error: String(error) };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Parse Task from JSON-RPC response
+     */
+    parseTask(data) {
+        const task = {
+            id: String(data.id || ''),
+            status: this.parseTaskStatus(data.status),
+            messages: [],
+            artifacts: undefined,
+            createdAt: data.createdAt ? String(data.createdAt) : undefined,
+            updatedAt: data.updatedAt ? String(data.updatedAt) : undefined,
+            contextId: data.contextId ? String(data.contextId) : undefined,
+        };
+        // Parse messages (A2A uses 'history' field, some agents use 'messages')
+        const messageList = Array.isArray(data.history) ? data.history :
+            Array.isArray(data.messages) ? data.messages : [];
+        if (messageList.length > 0) {
+            task.messages = messageList.map(msg => this.parseMessage(msg));
+        }
+        // Parse artifacts
+        if (Array.isArray(data.artifacts)) {
+            task.artifacts = data.artifacts.map(art => ({
+                name: art.name ? String(art.name) : undefined,
+                description: art.description ? String(art.description) : undefined,
+                parts: Array.isArray(art.parts)
+                    ? art.parts.map((part) => this.parsePart(part))
+                    : [],
+            }));
+        }
+        return task;
+    }
+    /**
+     * Parse Message from JSON-RPC response
+     */
+    parseMessage(data) {
+        if (!data || typeof data !== 'object') {
+            return { role: 'user', parts: [] };
+        }
+        const obj = data;
+        const message = {
+            // A2A protocol uses 'agent' for assistant responses
+            role: (obj.role === 'assistant' || obj.role === 'agent') ? 'assistant' : 'user',
+            parts: [],
+            metadata: obj.metadata,
+            contextId: obj.contextId ? String(obj.contextId) : undefined,
+            referenceTaskIds: Array.isArray(obj.referenceTaskIds)
+                ? obj.referenceTaskIds.map(String)
+                : undefined,
+        };
+        if (Array.isArray(obj.parts)) {
+            message.parts = obj.parts.map(part => this.parsePart(part));
+        }
+        return message;
+    }
+    /**
+     * Parse Message Part from JSON-RPC response
+     */
+    parsePart(data) {
+        if (!data || typeof data !== 'object') {
+            return { text: '' };
+        }
+        const obj = data;
+        // TextPart
+        if ('text' in obj && typeof obj.text === 'string') {
+            return { text: obj.text };
+        }
+        // DataPart (file data)
+        if ('data' in obj && 'mimeType' in obj) {
+            return {
+                data: String(obj.data),
+                mimeType: String(obj.mimeType),
+            };
+        }
+        // Fallback: if 'text' exists but not a string, convert
+        if ('text' in obj) {
+            return { text: String(obj.text) };
+        }
+        return { text: '' };
+    }
+    /**
+     * Parse task status string
+     */
+    parseTaskStatus(status) {
+        if (typeof status !== 'string') {
+            return 'pending';
+        }
+        const validStatuses = [
+            'pending',
+            'working',
+            'input_required',
+            'completed',
+            'failed',
+            'canceled',
+            'rejected',
+        ];
+        if (validStatuses.includes(status)) {
+            return status;
+        }
+        return 'pending';
+    }
+    /**
+     * Parse SSE event data
+     */
+    parseStreamEvent(data) {
+        if (!data || typeof data !== 'object')
+            return null;
+        const obj = data;
+        // JSON-RPC response wrapper
+        const result = obj.result;
+        if (!result)
+            return null;
+        // Check event type
+        if ('status' in result && 'taskId' in result) {
+            return {
+                type: 'status',
+                event: this.parseStatusEvent(result),
+            };
+        }
+        if ('artifact' in result && 'taskId' in result) {
+            return {
+                type: 'artifact',
+                event: this.parseArtifactEvent(result),
+            };
+        }
+        if ('id' in result && 'status' in result && 'messages' in result) {
+            return {
+                type: 'task',
+                task: this.parseTask(result),
+            };
+        }
+        if ('role' in result && 'parts' in result) {
+            return {
+                type: 'message',
+                message: this.parseMessage(result),
+            };
+        }
+        return null;
+    }
+    /**
+     * Parse status event
+     */
+    parseStatusEvent(data) {
+        return {
+            taskId: String(data.taskId || ''),
+            contextId: data.contextId ? String(data.contextId) : undefined,
+            status: this.parseTaskStatus(data.status),
+            message: data.message ? this.parseMessage(data.message) : undefined,
+            final: Boolean(data.final),
+        };
+    }
+    /**
+     * Parse artifact event
+     */
+    parseArtifactEvent(data) {
+        const artifact = data.artifact || {};
+        return {
+            taskId: String(data.taskId || ''),
+            contextId: data.contextId ? String(data.contextId) : undefined,
+            artifact: {
+                name: artifact.name ? String(artifact.name) : undefined,
+                description: artifact.description ? String(artifact.description) : undefined,
+                parts: Array.isArray(artifact.parts)
+                    ? artifact.parts.map((p) => this.parsePart(p))
+                    : [],
+                index: typeof artifact.index === 'number' ? artifact.index : undefined,
+                append: Boolean(artifact.append),
+                lastChunk: Boolean(artifact.lastChunk),
+            },
+        };
+    }
+}
+// ===== Helper Functions =====
+import { TargetsStore } from '../db/targets-store.js';
+import { AgentCacheStore } from '../db/agent-cache-store.js';
+import { fetchAgentCard } from './agent-card.js';
+/**
+ * Create A2A client from agent ID
+ * Fetches Agent Card from cache or remote endpoint
+ */
+export async function createA2AClient(configDir, agentId) {
+    const targetsStore = new TargetsStore(configDir);
+    const cacheStore = new AgentCacheStore(configDir);
+    // Find agent by ID or prefix
+    const agents = targetsStore.list({ type: 'agent' });
+    const agent = agents.find(a => a.id === agentId || a.id.startsWith(agentId));
+    if (!agent) {
+        return { ok: false, error: `Agent '${agentId}' not found` };
+    }
+    if (!agent.enabled) {
+        return { ok: false, error: `Agent '${agentId}' is disabled` };
+    }
+    // Get agent config
+    const config = agent.config;
+    if (!config.url) {
+        return { ok: false, error: `Agent '${agentId}' has no URL configured` };
+    }
+    // Check cache
+    const cached = cacheStore.get(agent.id);
+    const now = new Date();
+    let agentCard = null;
+    if (cached?.agentCard && cached.expiresAt && new Date(cached.expiresAt) > now) {
+        // Use cached card
+        agentCard = cached.agentCard;
+    }
+    else if (cached?.agentCard && !cached.expiresAt) {
+        // Use cached card (no expiration)
+        agentCard = cached.agentCard;
+    }
+    else {
+        // Fetch fresh agent card
+        const fetchResult = await fetchAgentCard(config.url, { allowLocal: config.allow_local ?? false });
+        if (!fetchResult.ok || !fetchResult.agentCard) {
+            return {
+                ok: false,
+                error: `Failed to fetch agent card: ${fetchResult.error}`,
+            };
+        }
+        agentCard = fetchResult.agentCard;
+        // Update cache
+        const ttl = config.ttl_seconds || 3600;
+        const expiresAt = new Date(now.getTime() + ttl * 1000).toISOString();
+        cacheStore.set({
+            targetId: agent.id,
+            agentCard,
+            agentCardHash: fetchResult.hash,
+            fetchedAt: now.toISOString(),
+            expiresAt,
+        });
+    }
+    // Create client with allowLocal from config
+    const client = new A2AClient(agentCard, { allowLocal: config.allow_local ?? false });
+    return { ok: true, client, agentCard };
+}
+/**
+ * Probe agent capabilities (Phase 2.5)
+ *
+ * Detects agent capabilities by:
+ * 1. Checking Agent Card capabilities field (if present)
+ * 2. Probing tasks/list endpoint to detect task support
+ *
+ * Note: Streaming capability is only detected from Agent Card, not probed,
+ * because SSE probing is more complex and unreliable.
+ *
+ * @param agentCard - The agent's Agent Card
+ * @param _allowLocal - Reserved for future use (URL validation)
+ * @returns Promise<AgentCapabilities> with detected capabilities
+ */
+export async function probeCapabilities(agentCard, _allowLocal = false) {
+    // Default capabilities (all false)
+    const capabilities = {
+        tasks: false,
+        streaming: false,
+    };
+    // First, check Agent Card capabilities field (if present)
+    // This is the authoritative source if provided by the agent
+    if (agentCard.capabilities) {
+        if (agentCard.capabilities.streaming !== undefined) {
+            capabilities.streaming = agentCard.capabilities.streaming;
+        }
+    }
+    // Probe tasks/list endpoint
+    try {
+        const response = await fetch(agentCard.url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'probe-tasks',
+                method: 'tasks/list',
+                params: {},
+            }),
+            signal: AbortSignal.timeout(5000), // 5 second timeout for probe
+        });
+        // Check for successful JSON-RPC response
+        // A 200 with { "error": { "code": -32601, ... } } means method not found
+        if (response.ok) {
+            try {
+                const data = await response.json();
+                // Only set tasks=true if we get a result (not a JSON-RPC error)
+                if (data.result !== undefined && !data.error) {
+                    capabilities.tasks = true;
+                }
+            }
+            catch {
+                // If we can't parse JSON, assume tasks not supported
+            }
+        }
+    }
+    catch {
+        // On network error or timeout, assume tasks not supported (keep false)
+    }
+    // Note: We don't probe message/stream here because:
+    // 1. It's more complex (SSE)
+    // 2. The Agent Card capabilities field is the preferred source
+    // 3. Most A2A agents that support tasks also support streaming
+    return capabilities;
+}
+//# sourceMappingURL=client.js.map