@alvin0/ai-agent-sdk-a2a 0.1.0

package/dist/client-2bhYYreC.mjs

@@ -0,0 +1,651 @@
+import { i as beginA2AIntegrationOperation, n as a2aErrorCode, t as cleanupFailure } from "./cleanup-report-CTjMJ9EU.mjs";
+import { Role, TaskState } from "@a2a-js/sdk";
+import { ClientFactory, ClientFactory as ClientFactory$1, DefaultAgentCardResolver, DefaultAgentCardResolver as DefaultAgentCardResolver$1, JsonRpcTransportFactory, JsonRpcTransportFactory as JsonRpcTransportFactory$1, RestTransportFactory, RestTransportFactory as RestTransportFactory$1 } from "@a2a-js/sdk/client";
+import { detachedFrozen, waitForSettlement } from "@alvin0/ai-agent-sdk-core";
+
+//#region src/client/link-helpers.ts
+function unlinkReport(status, alreadyUnlinked, error = status === "failed" ? cleanupFailure("A2A_UNLINK_FAILED", "a2a-unlink", "A2A link removal failed") : void 0) {
+	return Object.freeze({
+		status,
+		alreadyUnlinked,
+		...error === void 0 ? {} : { error }
+	});
+}
+function defaultFactory(options) {
+	const transportOptions = {
+		...options.fetch === void 0 ? {} : { fetchImpl: options.fetch },
+		legacyCompat: { enabled: options.legacyCompat ?? false }
+	};
+	return new ClientFactory({ transports: [new JsonRpcTransportFactory(transportOptions), new RestTransportFactory(transportOptions)] });
+}
+
+//#endregion
+//#region src/client/http-redirect.ts
+const REDIRECT_STATUSES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const MAX_REDIRECT_HOPS = 5;
+/** Apply redirect policy manually so every target is validated before contact. */
+async function fetchA2AEndpoint(baseFetch, input, init, options) {
+	let currentInput = input;
+	let currentUrl = options.validateEndpoint(inputUrl(input));
+	let requestInit = {
+		...init,
+		signal: options.signal,
+		redirect: "manual"
+	};
+	for (let hop = 0;; hop++) {
+		const response = await raceAbort(Promise.resolve(baseFetch(currentInput, requestInit)), options.signal);
+		if (response.redirected === true || response.type === "opaqueredirect" || response.url.length > 0 && response.url !== currentUrl.href) {
+			await cancelResponse(response, options.teardownTimeoutMs);
+			throw new Error("A2A HTTP transport rejected an already-followed redirect");
+		}
+		if (!REDIRECT_STATUSES.has(response.status)) return response;
+		if (!options.allowRedirects) {
+			await cancelResponse(response, options.teardownTimeoutMs);
+			throw new Error("A2A HTTP transport rejected a redirect");
+		}
+		if (hop >= MAX_REDIRECT_HOPS) {
+			await cancelResponse(response, options.teardownTimeoutMs);
+			throw new Error(`A2A HTTP transport exceeded the ${MAX_REDIRECT_HOPS}-redirect limit`);
+		}
+		const location = response.headers.get("location");
+		if (location === null) {
+			await cancelResponse(response, options.teardownTimeoutMs);
+			throw new Error("A2A HTTP transport received a redirect without a location");
+		}
+		const nextUrl = options.validateEndpoint(new URL(location, currentUrl));
+		await cancelResponse(response, options.teardownTimeoutMs);
+		requestInit = redirectedInit(requestInit, input, response.status, nextUrl.origin !== currentUrl.origin);
+		currentInput = nextUrl;
+		currentUrl = nextUrl;
+	}
+}
+function redirectedInit(previous, original, status, crossesOrigin) {
+	const inputMethod = typeof Request !== "undefined" && original instanceof Request ? original.method : void 0;
+	const method = (previous.method ?? inputMethod ?? "GET").toUpperCase();
+	const switchesToGet = status === 303 || (status === 301 || status === 302) && method === "POST";
+	const inputHasBody = typeof Request !== "undefined" && original instanceof Request && original.body !== null;
+	if (!switchesToGet && (inputHasBody || typeof ReadableStream !== "undefined" && previous.body instanceof ReadableStream)) throw new Error("A2A HTTP transport cannot replay a streaming request across a redirect");
+	const sourceHeaders = previous.headers ?? (typeof Request !== "undefined" && original instanceof Request ? original.headers : void 0);
+	const headers = crossesOrigin ? new Headers() : new Headers(sourceHeaders);
+	if (switchesToGet) {
+		headers.delete("content-length");
+		headers.delete("content-type");
+	}
+	return {
+		...previous,
+		redirect: "manual",
+		headers,
+		...switchesToGet ? {
+			method: "GET",
+			body: null
+		} : {}
+	};
+}
+function inputUrl(input) {
+	return typeof input === "string" || input instanceof URL ? input.toString() : input.url;
+}
+async function cancelResponse(response, timeoutMs) {
+	if (response.body === null) return;
+	await waitForSettlement(response.body.cancel().catch(() => void 0), timeoutMs);
+}
+function raceAbort(pending, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("A2A operation aborted"));
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			cleanup();
+			reject(signal.reason ?? /* @__PURE__ */ new Error("A2A operation aborted"));
+		};
+		const cleanup = () => signal.removeEventListener("abort", abort);
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+
+//#endregion
+//#region src/client.ts
+/** Official A2A Protocol client transport and AgentTeam linking helpers. */
+/** A resolved official SDK client presented as an AgentTeam transport. */
+var A2AAgentLink = class {
+	protocol = "a2a/1.0";
+	agentId;
+	client;
+	agentCard;
+	options;
+	contexts = /* @__PURE__ */ new Map();
+	pendingContextKeys = /* @__PURE__ */ new Set();
+	timeoutMs;
+	teardownTimeoutMs;
+	maxRequestBytes;
+	maxResponseBytes;
+	maxTransportBytes;
+	maxStreamEvents;
+	maxStreamBytes;
+	maxContexts;
+	contextTtlMs;
+	constructor(client, options, agentCard) {
+		this.client = client;
+		this.options = snapshotLinkOptions(options);
+		this.agentCard = agentCard === void 0 ? void 0 : detachedFrozen(agentCard);
+		this.agentId = nonEmpty(options.agentId ?? agentCard?.name ?? options.baseUrl, "A2A linked agent id");
+		this.timeoutMs = positiveInteger(options.timeoutMs ?? 12e4, "timeoutMs");
+		this.teardownTimeoutMs = positiveInteger(options.teardownTimeoutMs ?? 3e4, "teardownTimeoutMs");
+		this.maxRequestBytes = positiveInteger(options.maxRequestBytes ?? 1048576, "maxRequestBytes");
+		this.maxResponseBytes = positiveInteger(options.maxResponseBytes ?? 1048576, "maxResponseBytes");
+		this.maxTransportBytes = positiveInteger(options.maxTransportBytes ?? 16777216, "maxTransportBytes");
+		this.maxStreamEvents = positiveInteger(options.maxStreamEvents ?? 1e4, "maxStreamEvents");
+		this.maxStreamBytes = positiveInteger(options.maxStreamBytes ?? 8388608, "maxStreamBytes");
+		this.maxContexts = positiveInteger(options.maxContexts ?? 1e3, "maxContexts");
+		this.contextTtlMs = positiveInteger(options.contextTtlMs ?? 18e5, "contextTtlMs");
+		if (options.historyLength !== void 0) positiveInteger(options.historyLength, "historyLength");
+	}
+	async send(input) {
+		const operation = beginA2AIntegrationOperation(input.logger, "a2a-client-link", "send");
+		const attempt = operation.attempt(1);
+		let contextKey;
+		let signal = input.signal;
+		try {
+			input.signal?.throwIfAborted();
+			contextKey = JSON.stringify([input.teamId, input.sender]);
+			const context = this.reserveContext(contextKey);
+			const request = this.request(input, context?.id);
+			if (byteLength(request) > this.maxRequestBytes) throw new Error(`A2A request exceeds the ${this.maxRequestBytes}-byte limit`);
+			signal = combineSignals(input.signal, AbortSignal.timeout(this.timeoutMs));
+			const requestOptions = {
+				signal,
+				...this.options.serviceParameters === void 0 ? {} : { serviceParameters: this.options.serviceParameters }
+			};
+			const streaming = this.options.streaming ?? this.agentCard?.capabilities?.streaming ?? false;
+			let result;
+			if (streaming) {
+				const stream = beginA2AIntegrationOperation(input.logger, "a2a-client-link", "stream");
+				const streamAttempt = stream.attempt(1);
+				try {
+					result = await this.sendStreaming(request, requestOptions);
+					streamAttempt.success();
+					stream.success();
+				} catch (error) {
+					if (signal.aborted) {
+						streamAttempt.abort();
+						stream.abort();
+					} else {
+						const code = a2aErrorCode(error);
+						streamAttempt.fail(code);
+						stream.fail(code);
+					}
+					throw error;
+				}
+			} else {
+				const wireResult = await raceWithSignal(this.client.sendMessage(request, requestOptions), signal);
+				if (byteLength(wireResult) > this.maxTransportBytes) throw new Error(`A2A transport response exceeds the ${this.maxTransportBytes}-byte limit`);
+				result = normalizeResult(wireResult);
+			}
+			if (byteLength(result) > this.maxResponseBytes) throw new Error(`A2A response exceeds the ${this.maxResponseBytes}-byte limit`);
+			if (result.contextId.length > 0) this.contexts.set(contextKey, {
+				id: result.contextId,
+				lastAccess: Date.now()
+			});
+			attempt.success();
+			operation.success();
+			return result;
+		} catch (error) {
+			if (signal?.aborted === true) {
+				attempt.abort();
+				operation.abort();
+			} else {
+				const code = a2aErrorCode(error);
+				attempt.fail(code);
+				operation.fail(code);
+			}
+			throw error;
+		} finally {
+			if (contextKey !== void 0) this.pendingContextKeys.delete(contextKey);
+		}
+	}
+	request(input, contextId) {
+		return {
+			tenant: "",
+			message: {
+				messageId: input.messageId,
+				contextId: contextId ?? "",
+				taskId: "",
+				role: Role.ROLE_USER,
+				parts: input.content.map(contentPart),
+				metadata: {
+					teamId: input.teamId,
+					sender: input.sender,
+					senderAgentId: input.senderAgentId
+				},
+				extensions: [],
+				referenceTaskIds: []
+			},
+			configuration: {
+				acceptedOutputModes: [...this.options.acceptedOutputModes ?? ["text/plain", "application/json"]],
+				taskPushNotificationConfig: void 0,
+				...this.options.historyLength === void 0 ? {} : { historyLength: this.options.historyLength },
+				returnImmediately: false
+			},
+			metadata: {
+				teamId: input.teamId,
+				sender: input.sender
+			}
+		};
+	}
+	async sendStreaming(request, options) {
+		let lastTask;
+		let lastMessage;
+		let taskId = "";
+		let contextId = request.message?.contextId ?? "";
+		let state;
+		const streamedArtifactText = [];
+		const streamedStatusText = [];
+		let eventCount = 0;
+		let streamBytes = 0;
+		const iterator = this.client.sendMessageStream(request, options)[Symbol.asyncIterator]();
+		let exhausted = false;
+		try {
+			while (true) {
+				const next = await raceWithSignal(iterator.next(), options.signal);
+				if (next.done === true) {
+					exhausted = true;
+					break;
+				}
+				const rawEvent = next.value;
+				eventCount++;
+				streamBytes += byteLength(rawEvent);
+				if (eventCount > this.maxStreamEvents) throw new Error(`A2A stream exceeds the ${this.maxStreamEvents}-event limit`);
+				if (streamBytes > this.maxStreamBytes) throw new Error(`A2A stream exceeds the ${this.maxStreamBytes}-byte limit`);
+				const event = detachedFrozen(rawEvent);
+				try {
+					this.options.onStreamEvent?.(event);
+				} catch {}
+				const payload = event.payload;
+				if (payload?.$case === "task") {
+					lastTask = payload.value;
+					taskId = payload.value.id;
+					contextId = payload.value.contextId;
+					state = payload.value.status?.state;
+				} else if (payload?.$case === "message") {
+					lastMessage = payload.value;
+					contextId = payload.value.contextId;
+					taskId = payload.value.taskId;
+				} else if (payload?.$case === "statusUpdate") {
+					taskId = payload.value.taskId;
+					contextId = payload.value.contextId;
+					state = payload.value.status?.state;
+					const text = textOfMessage(payload.value.status?.message);
+					if (text.length > 0) streamedStatusText.push(text);
+				} else if (payload?.$case === "artifactUpdate") {
+					taskId = payload.value.taskId;
+					contextId = payload.value.contextId;
+					const text = textOfParts(payload.value.artifact?.parts ?? []);
+					if (text.length > 0) streamedArtifactText.push(text);
+				}
+			}
+		} finally {
+			if (!exhausted) {
+				const close = iterator.return?.bind(iterator);
+				if (close !== void 0) {
+					if (!await waitForSettlement(Promise.resolve().then(async () => {
+						await close();
+					}), this.teardownTimeoutMs)) throw new Error(`A2A stream teardown exceeded ${this.teardownTimeoutMs}ms`);
+				}
+			}
+		}
+		if (lastMessage !== void 0 && (state === void 0 || taskId.length === 0)) return normalizeMessage(lastMessage);
+		if (lastMessage !== void 0) return Object.freeze({
+			kind: "task",
+			succeeded: state === TaskState.TASK_STATE_COMPLETED,
+			text: textOfMessage(lastMessage) || streamedArtifactText.join("") || streamedStatusText.at(-1) || "",
+			contextId,
+			taskId,
+			...state === void 0 ? {} : { state: taskStateName(state) }
+		});
+		if (lastTask !== void 0) {
+			const normalized = normalizeTask(lastTask);
+			const streamed = streamedArtifactText.join("") || streamedStatusText.at(-1) || "";
+			const effectiveState = state ?? lastTask.status?.state;
+			return Object.freeze({
+				...normalized,
+				succeeded: effectiveState === TaskState.TASK_STATE_COMPLETED,
+				text: normalized.text || streamed,
+				...effectiveState === void 0 ? {} : { state: taskStateName(effectiveState) }
+			});
+		}
+		if (taskId.length === 0) throw new Error("A2A stream ended without a message or task");
+		return Object.freeze({
+			kind: "task",
+			succeeded: state === TaskState.TASK_STATE_COMPLETED,
+			text: streamedArtifactText.join("") || streamedStatusText.at(-1) || "",
+			contextId,
+			taskId,
+			...state === void 0 ? {} : { state: taskStateName(state) }
+		});
+	}
+	reserveContext(key) {
+		const now = Date.now();
+		for (const [candidate, value] of this.contexts) if (now - value.lastAccess >= this.contextTtlMs) this.contexts.delete(candidate);
+		const existing = this.contexts.get(key);
+		if (existing !== void 0) {
+			existing.lastAccess = now;
+			return existing;
+		}
+		if (!this.pendingContextKeys.has(key) && this.contexts.size + this.pendingContextKeys.size >= this.maxContexts) throw new Error(`A2A link reached its ${this.maxContexts}-context limit`);
+		this.pendingContextKeys.add(key);
+	}
+};
+/** Discover an Agent Card and construct a protocol link with official transports. */
+async function createA2AAgentLink(options) {
+	const operation = beginA2AIntegrationOperation(options.logger, "a2a-client-link", "agent-card-resolve");
+	const attempt = operation.attempt(1);
+	try {
+		options = snapshotLinkOptions(options);
+		if ([
+			options.client,
+			options.agentCard,
+			options.baseUrl
+		].filter((value) => value !== void 0).length !== 1) throw new TypeError("createA2AAgentLink requires exactly one of client, agentCard, or baseUrl");
+		if (options.client !== void 0) {
+			const link = new A2AAgentLink(options.client, options);
+			attempt.success();
+			operation.success();
+			return link;
+		}
+		if (options.agentCard !== void 0) {
+			const cardOptions = { ...options };
+			validateAgentCard(options.agentCard, cardOptions);
+			const guardedFetch = endpointFetch(options.fetch ?? globalThis.fetch, cardOptions);
+			const factory = options.clientFactory ?? defaultFactory({
+				...cardOptions,
+				fetch: guardedFetch
+			});
+			const signal = AbortSignal.timeout(positiveInteger(options.timeoutMs ?? 12e4, "timeoutMs"));
+			const link = new A2AAgentLink(await raceWithSignal(factory.createFromAgentCard(options.agentCard), signal), cardOptions, options.agentCard);
+			attempt.success();
+			operation.success();
+			return link;
+		}
+		const baseUrl = validateEndpoint(options.baseUrl, options);
+		const discoveryOptions = { ...options };
+		const guardedFetch = endpointFetch(options.fetch ?? globalThis.fetch, discoveryOptions);
+		const resolver = new DefaultAgentCardResolver({
+			fetchImpl: guardedFetch,
+			legacyCompat: { enabled: options.legacyCompat ?? false }
+		});
+		const signal = AbortSignal.timeout(positiveInteger(options.timeoutMs ?? 12e4, "timeoutMs"));
+		const agentCard = await raceWithSignal(resolver.resolve(baseUrl.href, options.cardPath), signal);
+		validateAgentCard(agentCard, discoveryOptions);
+		const client = await raceWithSignal((options.clientFactory ?? defaultFactory({
+			...discoveryOptions,
+			fetch: guardedFetch
+		})).createFromAgentCard(agentCard), signal);
+		const link = new A2AAgentLink(client, discoveryOptions, agentCard);
+		attempt.success();
+		operation.success();
+		return link;
+	} catch (error) {
+		const code = a2aErrorCode(error);
+		attempt.fail(code);
+		operation.fail(code);
+		throw error;
+	}
+}
+/** Discover and add a remote A2A peer to the same roster local agents use. */
+async function linkA2AAgent(team, options) {
+	const linkOperation = beginA2AIntegrationOperation(options.logger, "a2a-client-link", "link");
+	const linkAttempt = linkOperation.attempt(1);
+	let link;
+	let removeLink;
+	try {
+		link = await createA2AAgentLink(options);
+		removeLink = team.linkAgent({
+			name: options.name,
+			transport: link,
+			...options.description === void 0 ? {} : { description: options.description }
+		});
+		linkAttempt.success();
+		linkOperation.success();
+	} catch (error) {
+		const code = a2aErrorCode(error);
+		linkAttempt.fail(code);
+		linkOperation.fail(code);
+		throw error;
+	}
+	let report;
+	const unlink = () => {
+		if (report !== void 0) return;
+		const operation = beginA2AIntegrationOperation(options.logger, "a2a-client-link", "unlink");
+		const attempt = operation.attempt(1);
+		try {
+			removeLink();
+			report = unlinkReport("unlinked", false);
+			attempt.success();
+			operation.success();
+		} catch (error) {
+			report = unlinkReport("failed", false);
+			const code = a2aErrorCode(error);
+			attempt.fail(code);
+			operation.fail(code);
+			throw error;
+		}
+	};
+	const unlinkWithReport = () => {
+		if (report !== void 0) return unlinkReport(report.status, true, report.error);
+		const operation = beginA2AIntegrationOperation(options.logger, "a2a-client-link", "unlink");
+		const attempt = operation.attempt(1);
+		try {
+			removeLink();
+			report = unlinkReport("unlinked", false);
+			attempt.success();
+			operation.success();
+		} catch (error) {
+			report = unlinkReport("failed", false);
+			const code = a2aErrorCode(error);
+			attempt.fail(code);
+			operation.fail(code);
+		}
+		return report;
+	};
+	return Object.freeze({
+		link,
+		unlink,
+		unlinkWithReport
+	});
+}
+function contentPart(block) {
+	if (block.type === "text") return part({
+		$case: "text",
+		value: block.text
+	}, "text/plain");
+	if (block.type === "image") {
+		if (block.source.kind === "url") return part({
+			$case: "url",
+			value: block.source.url
+		}, "image/*");
+		if (block.source.kind === "base64") return part({
+			$case: "url",
+			value: `data:${block.source.mediaType};base64,${block.source.data}`
+		}, block.source.mediaType);
+		return part({
+			$case: "data",
+			value: {
+				type: "image-file",
+				fileId: block.source.fileId
+			}
+		}, "application/json");
+	}
+	return part({
+		$case: "data",
+		value: structuredClone(block)
+	}, "application/json");
+}
+function part(content, mediaType) {
+	return {
+		content,
+		metadata: void 0,
+		filename: "",
+		mediaType
+	};
+}
+function normalizeResult(result) {
+	return "messageId" in result ? normalizeMessage(result) : normalizeTask(result);
+}
+function normalizeMessage(message) {
+	return Object.freeze({
+		kind: "message",
+		succeeded: message.role === Role.ROLE_AGENT,
+		text: textOfMessage(message),
+		contextId: message.contextId,
+		...message.taskId.length === 0 ? {} : { taskId: message.taskId }
+	});
+}
+function normalizeTask(task) {
+	const state = task.status?.state;
+	const artifactText = task.artifacts.map((artifact) => textOfParts(artifact.parts)).filter(Boolean).join("\n");
+	const statusText = textOfMessage(task.status?.message);
+	const historyText = [...task.history].reverse().find((message) => message.role === Role.ROLE_AGENT);
+	return Object.freeze({
+		kind: "task",
+		succeeded: state === TaskState.TASK_STATE_COMPLETED,
+		text: artifactText || statusText || textOfMessage(historyText),
+		contextId: task.contextId,
+		taskId: task.id,
+		...state === void 0 ? {} : { state: taskStateName(state) }
+	});
+}
+function textOfMessage(message) {
+	return message === void 0 ? "" : textOfParts(message.parts);
+}
+function textOfParts(parts) {
+	return parts.flatMap((item) => item.content?.$case === "text" ? [item.content.value] : []).join("");
+}
+function taskStateName(state) {
+	return TaskState[state] ?? String(state);
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${label} must be a non-empty string`);
+	if (value.length > 256) throw new TypeError(`${label} must be at most 256 characters`);
+	return value;
+}
+function positiveInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${label} must be a positive integer`);
+	return value;
+}
+function utf8Bytes(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function byteLength(value) {
+	const serialized = JSON.stringify(value);
+	if (serialized === void 0) throw new TypeError("A2A value is not JSON serializable");
+	return utf8Bytes(serialized);
+}
+function combineSignals(...signals) {
+	const active = signals.filter((signal) => signal !== void 0);
+	if (active.length === 1) return active[0];
+	return AbortSignal.any(active);
+}
+async function raceWithSignal(pending, signal) {
+	if (signal === void 0) return pending;
+	if (signal.aborted) throw signal.reason ?? /* @__PURE__ */ new Error("A2A operation aborted");
+	return await new Promise((resolve, reject) => {
+		const abort = () => {
+			signal.removeEventListener("abort", abort);
+			reject(signal.reason ?? /* @__PURE__ */ new Error("A2A operation aborted"));
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then((value) => {
+			signal.removeEventListener("abort", abort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+function validateAgentCard(card, options) {
+	const maxBytes = positiveInteger(options.maxResponseBytes ?? 1048576, "maxResponseBytes");
+	if (byteLength(card) > maxBytes) throw new RangeError(`A2A Agent Card exceeds the ${maxBytes}-byte limit`);
+	if (card.supportedInterfaces.length === 0) throw new TypeError("A2A Agent Card must advertise at least one interface");
+	for (const item of card.supportedInterfaces) validateEndpoint(item.url, options);
+}
+function snapshotLinkOptions(options) {
+	return Object.freeze({
+		...options,
+		...options.allowedOrigins === void 0 ? {} : { allowedOrigins: Object.freeze([...options.allowedOrigins]) },
+		...options.acceptedOutputModes === void 0 ? {} : { acceptedOutputModes: Object.freeze([...options.acceptedOutputModes]) },
+		...options.serviceParameters === void 0 ? {} : { serviceParameters: detachedFrozen(options.serviceParameters) },
+		...options.agentCard === void 0 ? {} : { agentCard: detachedFrozen(options.agentCard) }
+	});
+}
+function validateEndpoint(value, options) {
+	const url = new URL(value);
+	if (url.username.length > 0 || url.password.length > 0) throw new TypeError("A2A endpoint URL must not contain credentials");
+	if (url.protocol !== "https:" && url.protocol !== "http:") throw new TypeError("A2A endpoint URL must use http or https");
+	if (options.requireHttps === true && url.protocol !== "https:") throw new TypeError("A2A endpoint URL must use https under the configured policy");
+	const allowedOrigins = options.allowedOrigins?.map((origin) => new URL(origin).origin);
+	if (allowedOrigins !== void 0 && !allowedOrigins.includes(url.origin)) throw new TypeError(`A2A endpoint origin '${url.origin}' is not allowed`);
+	if (options.allowPrivateNetwork === false && isPrivateHostname(url.hostname)) throw new TypeError(`A2A endpoint host '${url.hostname}' is private or local`);
+	options.validateEndpoint?.(new URL(url));
+	return url;
+}
+function endpointFetch(baseFetch, options) {
+	if (typeof baseFetch !== "function") throw new TypeError("A2A endpoint resolution requires fetch");
+	const maxBytes = positiveInteger(options.maxTransportBytes ?? 16777216, "maxTransportBytes");
+	const timeoutMs = positiveInteger(options.timeoutMs ?? 12e4, "timeoutMs");
+	const teardownTimeoutMs = positiveInteger(options.teardownTimeoutMs ?? 3e4, "teardownTimeoutMs");
+	return (async (input, init) => {
+		validateEndpoint(typeof input === "string" || input instanceof URL ? input.toString() : input.url, options);
+		const signal = combineSignals(init?.signal ?? void 0, AbortSignal.timeout(timeoutMs));
+		const response = await fetchA2AEndpoint(baseFetch, input, init, {
+			signal,
+			allowRedirects: options.allowRedirects !== false,
+			teardownTimeoutMs,
+			validateEndpoint: (value) => validateEndpoint(value.toString(), options)
+		});
+		if (response.url.length > 0) validateEndpoint(response.url, options);
+		const declared = Number(response.headers.get("content-length"));
+		if (Number.isFinite(declared) && declared > maxBytes) {
+			if (response.body !== null) await waitForSettlement(response.body.cancel().catch(() => void 0), teardownTimeoutMs);
+			throw new Error(`A2A HTTP response exceeds the ${maxBytes}-byte limit`);
+		}
+		if (response.body === null) return response;
+		let received = 0;
+		const limited = response.body.pipeThrough(new TransformStream({ transform(chunk, controller) {
+			received += chunk.byteLength;
+			if (received > maxBytes) {
+				controller.error(/* @__PURE__ */ new Error(`A2A HTTP response exceeds the ${maxBytes}-byte limit`));
+				return;
+			}
+			controller.enqueue(chunk);
+		} }));
+		return new Response(limited, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	});
+}
+function isPrivateHostname(value) {
+	const hostname = value.toLowerCase().replace(/^\[|\]$/g, "");
+	if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local") || hostname.endsWith(".internal") || hostname.endsWith(".home.arpa") || !hostname.includes(".")) return true;
+	if (hostname.includes(":")) return true;
+	const octets = hostname.split(".").map(Number);
+	if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet) || octet < 0 || octet > 255)) return false;
+	const [first = 0, second = 0] = octets;
+	return first === 0 || first === 10 || first === 127 || first >= 224 || first === 100 && second >= 64 && second <= 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 198 && (second === 18 || second === 19);
+}
+
+//#endregion
+export { RestTransportFactory$1 as a, JsonRpcTransportFactory$1 as i, ClientFactory$1 as n, createA2AAgentLink as o, DefaultAgentCardResolver$1 as r, linkA2AAgent as s, A2AAgentLink as t };
+//# sourceMappingURL=client-2bhYYreC.mjs.map