@alvin0/ai-agent-sdk-provider-http 0.1.0

package/dist/index.js

@@ -0,0 +1,1757 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, MODEL_ERROR_CODES, ModelAdapter, ModelError, ProviderRequestId, QUOTA_EXCEEDED_CODE, assertUsableApiKey, attributionHeaders, contentHasImage, createOperationId, detachedFrozen, isContextWindowExceededError, isQuotaExceededError, isSpanId, isTraceId, resolveRetryPolicy, safeErrorRecord, validateUsageCounters, waitForSettlement } from "@alvin0/ai-agent-sdk-core";
+import { createParser } from "eventsource-parser";
+import { AgentSdkError, CREDENTIAL_CAPABILITY_API_VERSION } from "@alvin0/ai-agent-sdk-core/provider";
+
+//#region src/common/config.ts
+/** Runtime wire-protocol contract version supported by this package. */
+const HTTP_PROTOCOL_API_VERSION = 1;
+/** Stable support-safe errors owned by the runtime HTTP extension path. */
+const HTTP_PROVIDER_ERROR_CODES = Object.freeze({
+	PROTOCOL_API_UNSUPPORTED: "HTTP_PROTOCOL_API_UNSUPPORTED",
+	HEADER_INVALID: "HTTP_HEADER_INVALID",
+	HEADER_RESERVED: "HTTP_HEADER_RESERVED",
+	HEADER_COLLISION: "HTTP_HEADER_COLLISION",
+	WIRE_BODY_INVALID: "HTTP_WIRE_BODY_INVALID",
+	WIRE_BODY_TOO_LARGE: "HTTP_WIRE_BODY_TOO_LARGE",
+	STREAM_MEDIA_TYPE_INVALID: "HTTP_STREAM_MEDIA_TYPE_INVALID",
+	SSE_LIMIT_EXCEEDED: "HTTP_SSE_LIMIT_EXCEEDED",
+	REDIRECT_REJECTED: "HTTP_REDIRECT_REJECTED"
+});
+const HTTP_PROTOCOL_LIMITS = Object.freeze({
+	idBytes: 128,
+	dialectDepth: 16,
+	dialectNodes: 4096,
+	dialectObjectFields: 1024,
+	dialectArrayItems: 4096,
+	dialectKeyBytes: 1024,
+	dialectBytes: 1048576
+});
+/** Structural limits for detached runtime-provider configuration snapshots. */
+const HTTP_RUNTIME_OPTION_LIMITS = Object.freeze({
+	maxDepth: 16,
+	maxNodes: 16384,
+	maxObjectFields: 4096,
+	maxArrayItems: 4096,
+	maxKeyBytes: 1024,
+	maxBytes: 4194304
+});
+/** Bounds for a failure envelope received across a package/runtime boundary. */
+const HTTP_FOREIGN_FAILURE_LIMITS = Object.freeze({
+	messageBytes: 2048,
+	codeBytes: 128,
+	requestIdBytes: 1024
+});
+
+//#endregion
+//#region src/stream/parser.ts
+/** Internal bounded parser used by the HTTP transport. */
+async function* parseSseBounded(stream, onActivity, teardownTimeoutMs, limits) {
+	const pending = [];
+	let emitted = 0;
+	const parser = createParser({
+		maxBufferSize: limits.maxEventChars,
+		onError(error) {
+			if (error.type === "max-buffer-size-exceeded") throw limitError("character");
+		},
+		onEvent(event) {
+			emitted++;
+			if (emitted > limits.maxEvents || event.data.length > limits.maxEventChars) throw limitError(emitted > limits.maxEvents ? "event-count" : "character");
+			pending.push({
+				event: event.event,
+				data: event.data
+			});
+		},
+		onComment() {
+			onActivity?.();
+		}
+	});
+	const decoder = new TextDecoder();
+	const reader = stream.getReader();
+	let drained = false;
+	let primaryFailure;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value !== void 0 && value.byteLength > 0) onActivity?.();
+			if (value !== void 0) parser.feed(decoder.decode(value, { stream: true }));
+			yield* drainBatch(pending);
+		}
+		const tail = decoder.decode();
+		if (tail.length > 0) {
+			parser.feed(tail);
+			yield* drainBatch(pending);
+		}
+		drained = true;
+	} catch (error) {
+		primaryFailure = error;
+		throw error;
+	} finally {
+		if (drained) reader.releaseLock();
+		else {
+			let cancellationFailure;
+			const cancellation = reader.cancel().catch((error) => {
+				cancellationFailure = error;
+			});
+			const settled = await waitForSettlement(cancellation, teardownTimeoutMs);
+			if (primaryFailure === void 0) {
+				if (!settled) throw new Error(`SSE body ignored cancellation for more than ${teardownTimeoutMs}ms`);
+				if (cancellationFailure !== void 0) throw cancellationFailure;
+			}
+		}
+	}
+}
+/** Cursor iteration avoids repeated array compaction from Array.shift(). */
+function* drainBatch(pending) {
+	for (let index = 0; index < pending.length; index++) {
+		const event = pending[index];
+		if (event !== void 0) yield event;
+	}
+	pending.length = 0;
+}
+function limitError(kind) {
+	return new ModelError(`provider SSE event buffer ${kind} limit exceeded`, HTTP_PROVIDER_ERROR_CODES.SSE_LIMIT_EXCEEDED);
+}
+
+//#endregion
+//#region src/stream/config.ts
+const DEFAULT_MAX_SSE_EVENTS = 1e5;
+const DEFAULT_MAX_SSE_EVENT_CHARS = 1048576;
+const DEFAULT_SSE_TEARDOWN_TIMEOUT_MS = 3e4;
+
+//#endregion
+//#region src/stream/idle-deadline.ts
+/**
+* Create one idle timer for a physical provider attempt.
+*
+* The parser calls `activity` while one `iterator.next()` is pending. Resetting
+* the same timer lets comment-only heartbeats keep that read alive without
+* manufacturing protocol events. A primary timeout is never replaced by a
+* secondary iterator-cancellation failure.
+*/
+function createStreamIdleDeadline(timeoutMs, displayName, teardownTimeoutMs) {
+	let timer;
+	let expired = false;
+	let rejectExpiry;
+	const expiry = new Promise((_resolve, reject) => {
+		rejectExpiry = reject;
+	});
+	expiry.catch(() => void 0);
+	const activity = () => {
+		if (expired) return;
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(() => {
+			expired = true;
+			rejectExpiry?.(new ModelError(`${displayName} stream idle for more than ${timeoutMs}ms`, MODEL_ERROR_CODES.TIMEOUT));
+		}, timeoutMs);
+	};
+	const dispose = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const guard = async function* (source) {
+		const iterator = source[Symbol.asyncIterator]();
+		let exhausted = false;
+		let primaryFailure;
+		activity();
+		try {
+			while (true) {
+				const result = await Promise.race([iterator.next(), expiry]);
+				if (result.done === true) {
+					exhausted = true;
+					return;
+				}
+				yield result.value;
+			}
+		} catch (error) {
+			primaryFailure = error;
+			throw error;
+		} finally {
+			dispose();
+			if (!exhausted) {
+				const close = iterator.return?.bind(iterator);
+				if (close !== void 0) {
+					let closeFailure;
+					const closing = Promise.resolve().then(async () => {
+						await close();
+					}).catch((error) => {
+						closeFailure = error;
+					});
+					const settled = await waitForSettlement(closing, teardownTimeoutMs);
+					if (primaryFailure === void 0) {
+						if (!settled) throw new ModelError(`${displayName} stream teardown exceeded ${teardownTimeoutMs}ms`, MODEL_ERROR_CODES.TEARDOWN_TIMEOUT);
+						if (closeFailure !== void 0) throw closeFailure;
+					}
+				}
+			}
+		}
+	};
+	return Object.freeze({
+		activity,
+		guard
+	});
+}
+
+//#endregion
+//#region src/stream/terminal.ts
+/**
+* Enforce the provider-neutral stream terminal contract.
+*
+* The finish chunk is held until the translator ends. That makes it impossible
+* for a custom protocol to expose a finish and then append more output. Earlier
+* output remains streaming; a truncated response after visible output is still
+* surfaced and therefore cannot be retried by the outer retry adapter.
+*/
+async function* requireTerminalFinish(source, displayName) {
+	let finish;
+	for await (const chunk of source) {
+		if (finish !== void 0) throw new ModelError(`${displayName} protocol emitted output after its terminal finish`, MODEL_ERROR_CODES.MALFORMED_RESPONSE);
+		if (chunk.type === "finish") {
+			finish = chunk;
+			continue;
+		}
+		yield chunk;
+	}
+	if (finish === void 0) throw new ModelError(`${displayName} response ended before a terminal finish`, MODEL_ERROR_CODES.STREAM_CLOSED);
+	yield finish;
+}
+
+//#endregion
+//#region src/common/failure.ts
+const ENCODER$1 = new TextEncoder();
+const INVALID_FIELD = Symbol("invalid failure field");
+/** Read an own data property without invoking getters or inherited state. */
+function ownDataProbe(source, key) {
+	try {
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor === void 0) return {
+			present: false,
+			data: true
+		};
+		if (!("value" in descriptor)) return {
+			present: true,
+			data: false
+		};
+		return {
+			present: true,
+			data: true,
+			value: descriptor.value
+		};
+	} catch {
+		return {
+			present: true,
+			data: false
+		};
+	}
+}
+function boundedString(value, maxBytes) {
+	return typeof value === "string" && value.length > 0 && ENCODER$1.encode(value).byteLength <= maxBytes;
+}
+function optionalFailureField(source, key) {
+	const field = ownDataProbe(source, key);
+	return field.data ? field.value : INVALID_FIELD;
+}
+/**
+* Validate the data twin carried by a ModelError from another core copy/realm.
+* A lone outer code is deliberately insufficient: retry policy may trust a code
+* only when the bounded inner envelope exists and agrees with it.
+*/
+function probeFailureEnvelope(value) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null) return { kind: "absent" };
+	const outerCode = ownDataProbe(value, "code");
+	const carried = ownDataProbe(value, "failure");
+	if (!outerCode.present && !carried.present) return { kind: "absent" };
+	if (!outerCode.data || !carried.data || !boundedString(outerCode.value, HTTP_FOREIGN_FAILURE_LIMITS.codeBytes) || typeof carried.value !== "object" || carried.value === null || Array.isArray(carried.value)) return { kind: "invalid" };
+	const message = optionalFailureField(carried.value, "message");
+	const code = optionalFailureField(carried.value, "code");
+	const status = optionalFailureField(carried.value, "status");
+	const providerRetryAfterMs = optionalFailureField(carried.value, "providerRetryAfterMs");
+	const requestId = optionalFailureField(carried.value, "requestId");
+	if (message === INVALID_FIELD || code === INVALID_FIELD || status === INVALID_FIELD || providerRetryAfterMs === INVALID_FIELD || requestId === INVALID_FIELD || !boundedString(message, HTTP_FOREIGN_FAILURE_LIMITS.messageBytes) || !boundedString(code, HTTP_FOREIGN_FAILURE_LIMITS.codeBytes) || code !== outerCode.value || status !== void 0 && (!Number.isSafeInteger(status) || status < 100 || status > 599) || providerRetryAfterMs !== void 0 && (!Number.isFinite(providerRetryAfterMs) || providerRetryAfterMs <= 0) || requestId !== void 0 && !boundedString(requestId, HTTP_FOREIGN_FAILURE_LIMITS.requestIdBytes)) return { kind: "invalid" };
+	return {
+		kind: "valid",
+		failure: Object.freeze({
+			message,
+			code,
+			...status === void 0 ? {} : { status },
+			...providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs },
+			...requestId === void 0 ? {} : { requestId }
+		})
+	};
+}
+/** Normalize a foreign provider failure without relying on package class identity. */
+function normalizeHttpBoundaryError(value, fallbackMessage) {
+	const envelope = probeFailureEnvelope(value);
+	if (envelope.kind === "absent") return new ModelError(fallbackMessage, MODEL_ERROR_CODES.TRANSPORT, { cause: value });
+	if (envelope.kind === "invalid") return new ModelError("provider supplied an invalid failure envelope", MODEL_ERROR_CODES.UNKNOWN, { cause: value });
+	const failure = envelope.failure;
+	return new ModelError(failure.message, failure.code, {
+		cause: value,
+		...failure.status === void 0 ? {} : { status: failure.status },
+		...failure.providerRetryAfterMs === void 0 ? {} : { providerRetryAfterMs: failure.providerRetryAfterMs },
+		...failure.requestId === void 0 ? {} : { requestId: failure.requestId }
+	});
+}
+
+//#endregion
+//#region src/common/header-layers.ts
+const DEFAULT_TRANSPORT_HEADERS = Object.freeze({
+	"content-type": "application/json",
+	accept: "text/event-stream"
+});
+const HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const FORBIDDEN_TRANSPORT_NAMES = /* @__PURE__ */ new Set([
+	"connection",
+	"content-length",
+	"host",
+	"proxy-authorization",
+	"proxy-authenticate",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+]);
+const TRANSPORT_OWNED_NAMES = /* @__PURE__ */ new Set(["accept", "content-type"]);
+const SDK_OWNED_NAMES = /* @__PURE__ */ new Set(["user-agent"]);
+const SDK_OWNED_PREFIXES = ["x-ai-agent-sdk-"];
+const SENSITIVE_NAME = /authorization|api[-_]?key|token|secret|cookie|account[-_]?id|signature/i;
+/** Conservative fallback used in addition to exact authentication provenance. */
+function isSensitiveHeaderName(name) {
+	return SENSITIVE_NAME.test(name);
+}
+/** Detach one layer without applying ownership rules that need all layers present. */
+function captureHeaderLayer(input) {
+	const output = Object.create(null);
+	const source = headerRecord(input.headers);
+	for (const key of Reflect.ownKeys(source)) {
+		if (typeof key !== "string") throw headerError("Header names must be strings", "HEADER_INVALID");
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (descriptor === void 0 || !("value" in descriptor)) throw headerError("Header values must not use accessors", "HEADER_INVALID");
+		const name = key.toLowerCase();
+		validateHeaderShape(name, descriptor.value);
+		if (Object.hasOwn(output, name)) throw headerError("Header names must be unique case-insensitively", "HEADER_COLLISION");
+		output[name] = descriptor.value;
+	}
+	return Object.freeze({
+		layer: input.layer,
+		headers: Object.freeze(output)
+	});
+}
+/** Validate five case-insensitive ownership layers and return one detached snapshot. */
+function mergeHeaderLayers(layers) {
+	const output = Object.create(null);
+	const owners = /* @__PURE__ */ new Map();
+	const sensitive = /* @__PURE__ */ new Set();
+	for (const raw of layers) {
+		const input = captureHeaderLayer(raw);
+		for (const [name, value] of Object.entries(input.headers)) {
+			const first = owners.get(name);
+			if (first !== void 0) throw headerError(`Header ownership collision between ${first} and ${input.layer}`, "HEADER_COLLISION");
+			validateHeaderOwnership(name, input.layer);
+			owners.set(name, input.layer);
+			output[name] = value;
+			if (input.layer === "auth") sensitive.add(name);
+		}
+	}
+	return Object.freeze({
+		headers: Object.freeze(output),
+		sensitiveHeaderNames: Object.freeze([...sensitive])
+	});
+}
+function headerRecord(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw headerError("Headers must be a record", "HEADER_INVALID");
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw headerError("Headers must be a plain record", "HEADER_INVALID");
+	return value;
+}
+function validateHeaderShape(name, value) {
+	if (!HEADER_NAME.test(name) || name.length > 256 || typeof value !== "string" || value.length > 16384 || /[\r\n\0]/.test(value)) throw headerError("Header name or value is invalid", "HEADER_INVALID");
+}
+function validateHeaderOwnership(name, layer) {
+	if (FORBIDDEN_TRANSPORT_NAMES.has(name) || name.startsWith("sec-") || name.startsWith("proxy-")) throw headerError("Header name is reserved by the transport", "HEADER_RESERVED");
+	if (TRANSPORT_OWNED_NAMES.has(name) && layer !== "transport") throw headerError("Header name is owned by the transport layer", "HEADER_RESERVED");
+	if (SDK_OWNED_NAMES.has(name) && layer !== "sdk-attribution") throw headerError("Header name is owned by SDK attribution", "HEADER_RESERVED");
+	if (SDK_OWNED_PREFIXES.some((prefix) => name.startsWith(prefix)) && layer !== "sdk-attribution") throw headerError("Header prefix is owned by SDK attribution", "HEADER_RESERVED");
+	if (isSensitiveHeaderName(name) && layer !== "auth") throw headerError("Credential headers must be supplied by auth", "HEADER_RESERVED");
+}
+function headerError(message, key) {
+	return new AgentSdkError(message, HTTP_PROVIDER_ERROR_CODES[key]);
+}
+
+//#endregion
+//#region src/base/http-errors.ts
+/**
+* The HTTP-to-taxonomy mapping every provider shares.
+*
+* Kept here rather than per provider because the interesting decisions are
+* genuinely vendor-independent: a 429 that means "slow down" versus one that
+* means "your balance is gone", and a 400 that means "your prompt is too long"
+* versus one that means "your schema is wrong". Both distinctions are invisible
+* in the status code and both change what the caller should do, so getting them
+* right once is worth more than getting them right three times.
+*
+* @module ai-agent-sdk/providers/base/http-errors
+*/
+/**
+* Map an HTTP status plus whatever the provider said into a stable code.
+*
+* `detail` should be the provider's error `code`, `type`, and `message` joined
+* into one string — the wording classifiers need all three because providers
+* disagree about which field carries the useful part.
+* @param status - status of a non-2xx response.
+* @param detail - provider error text, joined; empty string when the body was unparseable.
+* @returns the normalized code.
+*/
+function httpErrorCode(status, detail = "") {
+	if (status === 401 || status === 403) return MODEL_ERROR_CODES.AUTH;
+	if (status === 413) return MODEL_ERROR_CODES.INVALID_REQUEST;
+	if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+	if (status === 429) return MODEL_ERROR_CODES.RATE_LIMIT;
+	if (status === 400 || status === 422) return isContextWindowExceededError(detail) ? CONTEXT_WINDOW_EXCEEDED_CODE : MODEL_ERROR_CODES.INVALID_REQUEST;
+	if (status === 404) return MODEL_ERROR_CODES.INVALID_REQUEST;
+	if (status >= 500) return MODEL_ERROR_CODES.SERVER;
+	return `HTTP_${status}`;
+}
+/**
+* Parse a `retry-after` header into milliseconds.
+*
+* The header comes in two forms — delta-seconds and an HTTP date — and both are
+* used in practice. A date already in the past yields `undefined` rather than a
+* negative delay.
+* @param value - the raw header value, or `null` when absent.
+* @returns a positive finite delay, or `undefined` when absent or unusable.
+*/
+function retryAfterMs(value) {
+	if (value === null) return void 0;
+	const trimmed = value.trim();
+	if (/^\d+$/.test(trimmed)) {
+		const delay = Number(trimmed) * 1e3;
+		return Number.isFinite(delay) && delay > 0 ? delay : void 0;
+	}
+	const delay = Date.parse(trimmed) - Date.now();
+	return Number.isFinite(delay) && delay > 0 ? delay : void 0;
+}
+/** Header names providers use for their request correlation id, in priority order. */
+const REQUEST_ID_HEADERS = [
+	"request-id",
+	"x-request-id",
+	"x-requestid",
+	"cf-ray"
+];
+/**
+* Extract a provider request id for diagnostics.
+*
+* Worth capturing even though nothing programmatic reads it: when a provider is
+* misbehaving, this id is what their support needs to find the request.
+* @param headers - the response headers.
+* @returns the first non-empty id found, or `undefined`.
+*/
+function requestIdFrom(headers) {
+	for (const name of REQUEST_ID_HEADERS) {
+		const value = headers.get(name);
+		if (value !== null && value.length > 0) return ProviderRequestId(value);
+	}
+}
+/** Read a string property from an unknown object without trusting its shape. */
+function stringField(source, key) {
+	if (typeof source !== "object" || source === null) return void 0;
+	const value = source[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* Reduce a provider error body to a message and a classifier detail string.
+*
+* Handles the two shapes both providers use — `{error: {...}}` and a bare
+* `{type, message}` — and tolerates a body that is not JSON at all, which is what
+* a gateway or load balancer in front of the provider will return.
+* @param raw - the response body as text.
+* @returns the message and joined detail.
+*/
+function parseErrorBody(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {
+			message: void 0,
+			detail: raw.slice(0, 2048)
+		};
+	}
+	const error = typeof parsed === "object" && parsed !== null && "error" in parsed ? parsed.error : parsed;
+	const code = stringField(error, "code");
+	const type = stringField(error, "type");
+	const message = stringField(error, "message");
+	const detailField = stringField(error, "detail") ?? stringField(parsed, "detail");
+	const parts = [
+		code,
+		type,
+		message ?? detailField
+	].filter((part) => part !== void 0);
+	return {
+		message: message ?? detailField,
+		detail: parts.join(" ")
+	};
+}
+
+//#endregion
+//#region src/base/transport.ts
+function boundedResponseBody(source, maxBytes, maxChunks, displayName, signal) {
+	let bytes = 0;
+	let chunks = 0;
+	return source.pipeThrough(new TransformStream({ transform(chunk, controller) {
+		chunks++;
+		bytes += chunk.byteLength;
+		if (chunks > maxChunks) throw new ModelError(`${displayName} response exceeds the ${maxChunks}-chunk limit`, MODEL_ERROR_CODES.TRANSPORT);
+		if (bytes > maxBytes) throw new ModelError(`${displayName} response exceeds the ${maxBytes}-byte limit`, MODEL_ERROR_CODES.TRANSPORT);
+		controller.enqueue(chunk);
+	} }), signal === void 0 ? void 0 : { signal });
+}
+async function readBoundedText(response, maxBytes, signal) {
+	if (response.body === null) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let bytes = 0;
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await raceWithSignal(reader.read(), signal);
+			if (done) break;
+			if (value === void 0) continue;
+			const remaining = maxBytes - bytes;
+			if (remaining <= 0) {
+				await waitForSettlement(reader.cancel().catch(() => void 0), 3e4);
+				return `${text}\n[error body truncated at ${maxBytes} bytes]`;
+			}
+			const kept = value.byteLength <= remaining ? value : value.subarray(0, remaining);
+			bytes += kept.byteLength;
+			text += decoder.decode(kept, { stream: true });
+			if (kept.byteLength !== value.byteLength) {
+				await waitForSettlement(reader.cancel().catch(() => void 0), 3e4);
+				return `${text}${decoder.decode()}\n[error body truncated at ${maxBytes} bytes]`;
+			}
+		}
+		return text + decoder.decode();
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Reject every redirect shape exposed by Web fetch without following a second hop. */
+async function rejectProviderRedirect(response, requestedUrl) {
+	const redirectedStatus = response.status >= 300 && response.status < 400;
+	const finalUrlChanged = response.url.length > 0 && response.url !== requestedUrl;
+	if (response.type !== "opaqueredirect" && response.redirected !== true && !redirectedStatus && !finalUrlChanged) return;
+	if (response.body !== null) await waitForSettlement(response.body.cancel().catch(() => void 0), 3e4);
+	throw new ModelError("provider transport rejected a redirect before following it", HTTP_PROVIDER_ERROR_CODES.REDIRECT_REJECTED, response.status === 0 ? void 0 : { status: response.status });
+}
+async function raceWithSignal(pending, signal) {
+	if (signal.aborted) {
+		pending.catch(() => void 0);
+		throw signal.reason ?? /* @__PURE__ */ new Error("operation aborted");
+	}
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			signal.removeEventListener("abort", onAbort);
+			reject(signal.reason ?? /* @__PURE__ */ new Error("operation aborted"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		pending.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/** HTTP-specific ownership cleanup; generic Promise races must not dispose values. */
+async function cancelResponseBody(response) {
+	try {
+		if (response.body === null || response.body.locked) return;
+		await waitForSettlement(Promise.resolve().then(() => response.body.cancel()), 3e4);
+	} catch {}
+}
+async function* withAbortSignal(iterable, signal) {
+	const iterator = iterable[Symbol.asyncIterator]();
+	let exhausted = false;
+	try {
+		while (true) {
+			const next = await raceWithSignal(iterator.next(), signal);
+			if (next.done === true) {
+				exhausted = true;
+				return;
+			}
+			yield next.value;
+		}
+	} finally {
+		if (!exhausted) {
+			const close = iterator.return?.bind(iterator);
+			if (close !== void 0) {
+				const closing = Promise.resolve().then(async () => {
+					await close();
+				});
+				await waitForSettlement(closing, 3e4);
+			}
+		}
+	}
+}
+function positiveInteger(value, name) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`${name} must be a positive safe integer`);
+	return value;
+}
+function positiveFinite$1(value, name) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	return value;
+}
+function endpointUrl(baseUrl, path, allowInsecureHttp) {
+	let base;
+	try {
+		base = new URL(baseUrl);
+	} catch (error) {
+		throw new ModelError("provider baseUrl is not a valid absolute URL", MODEL_ERROR_CODES.INVALID_REQUEST, { cause: error });
+	}
+	if (base.username.length > 0 || base.password.length > 0) throw new ModelError("provider baseUrl must not contain credentials", MODEL_ERROR_CODES.INVALID_REQUEST);
+	if (base.search.length > 0 || base.hash.length > 0) throw new ModelError("provider baseUrl must not contain a query or fragment", MODEL_ERROR_CODES.INVALID_REQUEST);
+	if (base.protocol !== "https:" && !(allowInsecureHttp && base.protocol === "http:")) throw new ModelError("provider baseUrl must use HTTPS unless allowInsecureHttp is explicitly enabled", MODEL_ERROR_CODES.INVALID_REQUEST);
+	const normalizedBase = base.href.replace(/\/+$/, "");
+	let endpoint;
+	try {
+		endpoint = new URL(`${normalizedBase}${path}`);
+	} catch (error) {
+		throw new ModelError("provider endpoint path produced an invalid URL", MODEL_ERROR_CODES.INVALID_REQUEST, { cause: error });
+	}
+	if (endpoint.origin !== base.origin) throw new ModelError("provider endpoint path must remain on the configured origin", MODEL_ERROR_CODES.INVALID_REQUEST);
+	return endpoint;
+}
+function safeProviderFailure(failure) {
+	return Object.freeze({
+		type: "ModelError",
+		message: "provider attempt failed; inspect the stable code and request ID",
+		code: failure.code,
+		...failure.status === void 0 ? {} : { status: failure.status }
+	});
+}
+function redactHeaders(headers, sensitiveHeaderNames = []) {
+	const provenance = new Set(sensitiveHeaderNames.map((name) => name.toLowerCase()));
+	return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, provenance.has(name.toLowerCase()) || isSensitiveHeaderName(name) ? "[REDACTED]" : value]));
+}
+function requestLogId() {
+	return globalThis.crypto?.randomUUID?.() ?? `request-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function catalogModelInfo(provider, model) {
+	return {
+		provider,
+		id: model.id,
+		name: model.name ?? model.id,
+		...model.description === void 0 ? {} : { description: model.description },
+		inputModalities: model.inputModalities ?? ["text"],
+		...model.outputModalities === void 0 ? {} : { outputModalities: model.outputModalities },
+		...model.nativeTools === void 0 ? {} : { nativeTools: model.nativeTools }
+	};
+}
+/** Resolve exact metadata from an advisory catalog without opening a connection. */
+function resolvedCatalogModelInfo(provider, modelId, models, defaultMaxTokens, defaultContextWindow) {
+	const configured = models.find((entry) => entry.id === modelId);
+	return {
+		...configured === void 0 ? {
+			provider,
+			id: modelId,
+			name: modelId,
+			inputModalities: ["text"]
+		} : catalogModelInfo(provider, configured),
+		context: { contextWindow: configured?.contextWindow ?? defaultContextWindow },
+		defaultMaxTokens: configured?.maxTokens ?? defaultMaxTokens,
+		maxOutputTokens: configured?.maxTokens ?? defaultMaxTokens,
+		...configured?.reasoning === void 0 ? {} : { reasoning: configured.reasoning },
+		...configured?.outputModalities === void 0 ? {} : { outputModalities: configured.outputModalities }
+	};
+}
+function abortError(displayName, cause) {
+	return new ModelError(`${displayName} request aborted by caller`, MODEL_ERROR_CODES.ABORTED, { cause });
+}
+
+//#endregion
+//#region src/base/http-adapter.ts
+/**
+* The single HTTP/SSE pipeline every provider in this package runs through.
+*
+* This is a template method, and that is the point. `stream()` is implemented
+* HERE and is not an extension point: a provider cannot accidentally ship its own
+* fetch loop that forgets attribution headers, mishandles abort, leaks a response
+* body, or invents its own error codes. What a provider supplies is only the four
+* things that are genuinely vendor-specific:
+*
+* - {@link HttpModelAdapter.connect} — where to send it and with what credentials
+* - {@link HttpModelAdapter.endpointPath} — the path under the base URL
+* - {@link HttpModelAdapter.buildBody} — normalized request to wire JSON
+* - {@link HttpModelAdapter.translate} — wire SSE events to `StreamChunk`s
+*
+* Everything else — connection snapshotting, the catalog, modality checks, the
+* request, HTTP error mapping, `retry-after`, request ids, SSE decoding, the idle
+* bound, and teardown — is shared and happens exactly once, here.
+*
+* @module ai-agent-sdk/providers/base/http-adapter
+*/
+/** Default idle bound: five minutes without a single byte is a hung stream. */
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+/** Default end-to-end bound once provider request construction begins. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 6e5;
+/** Default serialized request ceiling. */
+const DEFAULT_MAX_REQUEST_BYTES = 33554432;
+/** Default cumulative successful response-body ceiling. */
+const DEFAULT_MAX_RESPONSE_BYTES = 33554432;
+/** Default number of raw response chunks accepted from one request. */
+const DEFAULT_MAX_RESPONSE_CHUNKS = 1e5;
+/** Default error body retained for classification and diagnostics. */
+const DEFAULT_MAX_ERROR_BODY_BYTES = 1048576;
+/** Default diagnostic observer deadline; logging must never gate dispatch indefinitely. */
+const DEFAULT_REQUEST_LOGGER_TIMEOUT_MS = 5e3;
+/** Base for every HTTP provider adapter in this package. */
+var HttpModelAdapter = class extends ModelAdapter {
+	/**
+	* Extra headers merged in by the base pipeline. Override to change `accept`.
+	* @returns headers applied beneath {@link HttpConnection.headers}.
+	*/
+	baseHeaders() {
+		return {
+			"content-type": "application/json",
+			"accept": "text/event-stream"
+		};
+	}
+	/**
+	* Observe an exact, credential-redacted wire request before dispatch.
+	*
+	* The default is a no-op so library users do not silently persist prompts.
+	* Implementations should treat this as diagnostics, not a dispatch veto.
+	* @deprecated High-risk compatibility diagnostics; prefer structured observation.
+	*/
+	observeRequest(_record) {}
+	/**
+	* Map a non-2xx response to a stable code. Override only to add codes this
+	* provider reports that the shared mapping cannot infer from the status.
+	*/
+	providerErrorCode(status, detail) {
+		return httpErrorCode(status, detail);
+	}
+	providerInfo(provider) {
+		return {
+			id: provider,
+			name: this.displayName
+		};
+	}
+	async listModels(provider, signal) {
+		return this.captureConnection(await this.connect(provider, signal)).models.map((model) => catalogModelInfo(provider, model));
+	}
+	async resolveModel(provider, model, signal) {
+		const connection = this.captureConnection(await this.connect(provider, signal));
+		return this.decorateModel(this.modelInfoFor(connection, provider, model), connection);
+	}
+	async prepareCall(provider, model, signal, context) {
+		context?.declareProviderAttemptAccounting?.();
+		const connection = this.captureConnection(await this.connect(provider, signal, context));
+		const info = this.decorateModel(this.modelInfoFor(connection, provider, model), connection);
+		const wireBody = {};
+		return {
+			model: info,
+			stream: (options, invocation = context) => this.run(options, connection, info, invocation, wireBody)
+		};
+	}
+	/**
+	* Stream one model call.
+	*
+	* Intentionally NOT an extension point — see the module note. Providers
+	* customize behaviour through the abstract members instead.
+	*/
+	stream(options, context) {
+		return this.runResolving(options, context);
+	}
+	/** Resolve a connection first, for the un-prepared entry point. */
+	async *runResolving(options, context) {
+		context?.declareProviderAttemptAccounting?.();
+		const connection = this.captureConnection(await this.connect(options.provider, options.signal, context));
+		const info = this.decorateModel(this.modelInfoFor(connection, options.provider, options.model), connection);
+		yield* this.run(options, connection, info, context, {});
+	}
+	/** Resolve exact-model metadata from the catalog, falling back to config defaults. */
+	modelInfoFor(connection, provider, model) {
+		return resolvedCatalogModelInfo(provider, model, connection.models, connection.defaultMaxTokens, connection.defaultContextWindow);
+	}
+	/** Decorate resolved metadata without reopening the captured connection generation. */
+	decorateModel(info, _connection) {
+		return info;
+	}
+	/** Capture legacy subclass transport/auth layers once; configured adapters already return all five. */
+	captureConnection(connection) {
+		const transport = this.baseHeaders();
+		if (Reflect.ownKeys(transport).length === 0) return connection;
+		const merged = mergeHeaderLayers([
+			{
+				layer: "transport",
+				headers: transport
+			},
+			{
+				layer: "sdk-attribution",
+				headers: attributionHeaders()
+			},
+			{
+				layer: "auth",
+				headers: connection.headers
+			}
+		]);
+		return Object.freeze({
+			...connection,
+			headers: merged.headers,
+			sensitiveHeaderNames: Object.freeze([.../* @__PURE__ */ new Set([...connection.sensitiveHeaderNames ?? [], ...merged.sensitiveHeaderNames])])
+		});
+	}
+	/**
+	* The shared pipeline: guard, build, send, classify, decode, bound, translate.
+	*/
+	async *run(options, connection, model, context, wireBodyCache = {}) {
+		context?.declareProviderAttemptAccounting?.();
+		if (options.messages.some((message) => contentHasImage(message.content)) && model.inputModalities?.includes("image") !== true) throw new ModelError(`${this.displayName} model "${options.model}" does not accept image input`, MODEL_ERROR_CODES.UNSUPPORTED_CONTENT);
+		const request = {
+			options,
+			model,
+			connection,
+			maxTokens: options.maxTokens ?? model.defaultMaxTokens ?? connection.defaultMaxTokens
+		};
+		const consumer = new AbortController();
+		const requestTimeoutMs = positiveFinite$1(connection.requestTimeoutMs ?? 6e5, "requestTimeoutMs");
+		const timeout = AbortSignal.timeout(requestTimeoutMs);
+		const signal = AbortSignal.any([
+			consumer.signal,
+			timeout,
+			...options.signal === void 0 ? [] : [options.signal]
+		]);
+		const maxRequestBytes = positiveInteger(connection.maxRequestBytes ?? 33554432, "maxRequestBytes");
+		const maxResponseBytes = positiveInteger(connection.maxResponseBytes ?? 33554432, "maxResponseBytes");
+		const maxResponseChunks = positiveInteger(connection.maxResponseChunks ?? 1e5, "maxResponseChunks");
+		const maxSseEvents = positiveInteger(connection.maxSseEvents ?? 1e5, "maxSseEvents");
+		const maxSseEventChars = positiveInteger(connection.maxSseEventChars ?? 1048576, "maxSseEventChars");
+		const maxErrorBodyBytes = positiveInteger(connection.maxErrorBodyBytes ?? 1048576, "maxErrorBodyBytes");
+		const requestLoggerTimeoutMs = positiveFinite$1(connection.requestLoggerTimeoutMs ?? 5e3, "requestLoggerTimeoutMs");
+		let admissionFailure;
+		let ownedResponse;
+		try {
+			signal.throwIfAborted();
+			const preparedBody = await (wireBodyCache.prepared ??= this.prepareWireBody(request, maxRequestBytes, signal));
+			const wireBody = preparedBody.value;
+			const body = preparedBody.encoded;
+			const bodyBytes = preparedBody.bytes;
+			const endpoint = endpointUrl(connection.baseUrl, this.endpointPath(request), connection.allowInsecureHttp ?? false);
+			const url = endpoint.href;
+			const origin = endpoint.origin;
+			const headers = connection.headers;
+			try {
+				const loggerSignal = AbortSignal.any([signal, AbortSignal.timeout(requestLoggerTimeoutMs)]);
+				await raceWithSignal(Promise.resolve(this.observeRequest({
+					schemaVersion: 1,
+					type: "provider-request",
+					id: requestLogId(),
+					timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+					provider: options.provider,
+					model: options.model,
+					method: "POST",
+					url,
+					headers: redactHeaders(headers, connection.sensitiveHeaderNames),
+					body: wireBody,
+					bodyBytes
+				})), loggerSignal);
+			} catch {}
+			let attempt;
+			let dispatchState = "not-sent";
+			let httpStatus;
+			let providerRequestId;
+			let attemptStatus = "unknown";
+			let attemptUsage;
+			let attemptError;
+			try {
+				signal.throwIfAborted();
+				try {
+					attempt = await context?.startProviderAttempt?.({
+						provider: options.provider,
+						model: options.model,
+						method: "POST",
+						origin
+					}, signal);
+				} catch (error) {
+					admissionFailure = { value: error };
+					throw error;
+				}
+				signal.throwIfAborted();
+				dispatchState = "unknown";
+				const pendingResponse = (connection.fetch ?? globalThis.fetch)(url, {
+					method: "POST",
+					headers,
+					body,
+					signal,
+					redirect: "manual"
+				});
+				pendingResponse.then((response) => {
+					if (signal.aborted) return cancelResponseBody(response);
+				}, () => void 0);
+				const response = await raceWithSignal(pendingResponse, signal);
+				ownedResponse = response;
+				signal.throwIfAborted();
+				dispatchState = "sent";
+				httpStatus = response.status;
+				providerRequestId = requestIdFrom(response.headers);
+				await rejectProviderRedirect(response, url);
+				if (!response.ok) throw await this.httpFailure(response, origin, maxErrorBodyBytes, signal);
+				if (response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "text/event-stream") throw new ModelError(`${this.displayName} response is not text/event-stream`, HTTP_PROVIDER_ERROR_CODES.STREAM_MEDIA_TYPE_INVALID);
+				if (response.body === null) throw new ModelError(`${this.displayName} returned no response body`, MODEL_ERROR_CODES.STREAM_CLOSED);
+				const declaredLength = response.headers.get("content-length");
+				if (declaredLength !== null && /^\d+$/.test(declaredLength) && Number(declaredLength) > maxResponseBytes) throw new ModelError(`${this.displayName} response exceeds the ${maxResponseBytes}-byte limit`, MODEL_ERROR_CODES.TRANSPORT);
+				const idleDeadline = createStreamIdleDeadline(connection.streamIdleTimeoutMs, this.displayName, 3e4);
+				const events = parseSseBounded(boundedResponseBody(response.body, maxResponseBytes, maxResponseChunks, this.displayName, signal), idleDeadline.activity, 3e4, {
+					maxEvents: maxSseEvents,
+					maxEventChars: maxSseEventChars
+				});
+				const translated = requireTerminalFinish(this.translate(events, request), this.displayName);
+				for await (const chunk of withAbortSignal(idleDeadline.guard(translated), signal)) {
+					if (chunk.type === "usage") {
+						attemptUsage = chunk.usage;
+						const validated = validateUsageCounters(chunk.usage, true);
+						if (!validated.complete) continue;
+						yield {
+							type: "usage",
+							usage: validated.reported
+						};
+						continue;
+					}
+					if (chunk.type === "finish") {
+						attemptStatus = chunk.reason.kind === "aborted" ? "aborted" : chunk.reason.kind === "error" ? "error" : "success";
+						if (chunk.reason.kind === "error" || chunk.reason.kind === "aborted") attemptError = safeProviderFailure(chunk.reason.failure);
+					}
+					yield chunk;
+				}
+			} catch (error) {
+				if (admissionFailure !== void 0 && error === admissionFailure.value) throw error;
+				const mapped = timeout.aborted && options.signal?.aborted !== true ? new ModelError(`${this.displayName} request exceeded its ${requestTimeoutMs}ms time limit`, MODEL_ERROR_CODES.TIMEOUT, { cause: error }) : signal.aborted ? abortError(this.displayName, error) : normalizeHttpBoundaryError(error, `${this.displayName} request to ${origin} failed`);
+				attemptStatus = mapped.code === MODEL_ERROR_CODES.ABORTED ? "aborted" : "error";
+				attemptError = safeProviderFailure(mapped.failure);
+				throw mapped;
+			} finally {
+				attempt?.end({
+					status: attemptStatus,
+					dispatchState,
+					...attemptUsage === void 0 ? {} : { reported: attemptUsage },
+					...httpStatus === void 0 ? {} : { httpStatus },
+					...providerRequestId === void 0 ? {} : { providerRequestId },
+					...attemptError === void 0 ? {} : { error: attemptError }
+				});
+			}
+		} catch (error) {
+			if (options.signal?.aborted === true) throw abortError(this.displayName, error);
+			if (timeout.aborted) throw new ModelError(`${this.displayName} request exceeded its ${requestTimeoutMs}ms time limit`, MODEL_ERROR_CODES.TIMEOUT, { cause: error });
+			if (admissionFailure !== void 0 && error === admissionFailure.value) throw error;
+			throw normalizeHttpBoundaryError(error, `${this.displayName} stream failed`);
+		} finally {
+			consumer.abort(/* @__PURE__ */ new Error(`${this.displayName} stream consumer stopped`));
+			if (ownedResponse !== void 0) await cancelResponseBody(ownedResponse);
+		}
+	}
+	async prepareWireBody(request, maxRequestBytes, signal) {
+		signal.throwIfAborted();
+		const value = await raceWithSignal(Promise.resolve(this.buildBody(request)), signal);
+		const encoded = JSON.stringify(value);
+		const bytes = new TextEncoder().encode(encoded).byteLength;
+		if (bytes > maxRequestBytes) throw new ModelError(`${this.displayName} request exceeds the ${maxRequestBytes}-byte limit`, MODEL_ERROR_CODES.INVALID_REQUEST);
+		return Object.freeze({
+			value,
+			encoded,
+			bytes
+		});
+	}
+	/** Turn a non-2xx response into a fully populated {@link ModelError}. */
+	async httpFailure(response, url, maxBytes, signal) {
+		let raw = "";
+		try {
+			raw = await readBoundedText(response, maxBytes, signal);
+		} catch {}
+		const { message, detail } = parseErrorBody(raw);
+		const delay = retryAfterMs(response.headers.get("retry-after"));
+		const id = requestIdFrom(response.headers);
+		return new ModelError(message ?? `${this.displayName} error (HTTP ${response.status}) from ${url}`, this.providerErrorCode(response.status, detail), {
+			cause: new Error(raw.length > 0 ? raw : `HTTP ${response.status}`),
+			status: response.status,
+			...delay === void 0 ? {} : { providerRetryAfterMs: delay },
+			...id === void 0 ? {} : { requestId: id }
+		});
+	}
+};
+
+//#endregion
+//#region src/common/data.ts
+const ENCODER = new TextEncoder();
+/** Read an own data property without evaluating accessors or inherited state. */
+function ownData(source, key, required = true) {
+	const descriptor = Object.getOwnPropertyDescriptor(source, key);
+	if (descriptor === void 0) {
+		if (!required) return void 0;
+		throw new TypeError(`Missing ${String(key)}`);
+	}
+	if (!("value" in descriptor)) throw new TypeError(`${String(key)} must not be an accessor`);
+	return descriptor.value;
+}
+/** Require a plain configuration object. */
+function plainObject(value, label) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${label} must be a plain object`);
+	return value;
+}
+/** Capture a method once while retaining its original receiver. */
+function capturedMethod(source, key) {
+	const value = ownData(source, key);
+	if (typeof value !== "function") throw new TypeError(`${String(key)} must be a function`);
+	return (...args) => Reflect.apply(value, source, args);
+}
+/** Capture an optional method once while retaining its original receiver. */
+function optionalCapturedMethod(source, key) {
+	const value = ownData(source, key, false);
+	if (value === void 0) return void 0;
+	if (typeof value !== "function") throw new TypeError(`${String(key)} must be a function`);
+	return (...args) => Reflect.apply(value, source, args);
+}
+/** Validate one bounded non-empty UTF-8 identifier. */
+function boundedIdentifier(value, maxBytes, label) {
+	if (typeof value !== "string" || value.length === 0 || value.trim() !== value || ENCODER.encode(value).byteLength > maxBytes) throw new TypeError(`${label} must be a bounded non-empty string`);
+	return value;
+}
+
+//#endregion
+//#region src/common/json-snapshot.ts
+/** Clone bounded JSON data without invoking accessors, prototypes, or serialization hooks. */
+function snapshotJsonObject(value, limits) {
+	let nodes = 0;
+	const seen = /* @__PURE__ */ new Set();
+	const encoder = new TextEncoder();
+	const clone = (input, depth) => {
+		nodes++;
+		if (nodes > limits.maxNodes || depth > limits.maxDepth) throw new TypeError("JSON data exceeds its structural bound");
+		if (input === null || typeof input === "boolean" || typeof input === "string") return input;
+		if (typeof input === "number") {
+			if (!Number.isFinite(input)) throw new TypeError("JSON number must be finite");
+			return input;
+		}
+		if (Array.isArray(input)) return cloneArray(input, depth);
+		if (input === null || typeof input !== "object") throw new TypeError("JSON data contains an unsupported value");
+		return cloneRecord(input, depth);
+	};
+	const cloneArray = (source, depth) => {
+		if (seen.has(source)) throw new TypeError("JSON data is cyclic");
+		const length = ownValue(source, "length");
+		if (!Number.isSafeInteger(length) || Number(length) < 0 || Number(length) > limits.maxArrayItems) throw new TypeError("JSON array exceeds its item bound");
+		seen.add(source);
+		try {
+			const result = [];
+			for (let index = 0; index < Number(length); index++) result.push(clone(ownValue(source, String(index)), depth + 1));
+			return Object.freeze(result);
+		} finally {
+			seen.delete(source);
+		}
+	};
+	const cloneRecord = (source, depth) => {
+		const prototype = Object.getPrototypeOf(source);
+		if (prototype !== Object.prototype && prototype !== null) throw new TypeError("JSON object must be plain");
+		if (seen.has(source)) throw new TypeError("JSON data is cyclic");
+		const keys = Reflect.ownKeys(source);
+		if (keys.some((key) => typeof key !== "string") || keys.length > limits.maxObjectFields) throw new TypeError("JSON object exceeds its field bound");
+		seen.add(source);
+		try {
+			const result = Object.create(null);
+			for (const key of keys) {
+				if (encoder.encode(key).byteLength > limits.maxKeyBytes) throw new TypeError("JSON object key exceeds its byte bound");
+				result[key] = clone(ownValue(source, key), depth + 1);
+			}
+			return Object.freeze(result);
+		} finally {
+			seen.delete(source);
+		}
+	};
+	const snapshot = clone(value, 0);
+	if (snapshot === null || Array.isArray(snapshot) || typeof snapshot !== "object") throw new TypeError("Expected a JSON object");
+	if (encoder.encode(JSON.stringify(snapshot)).byteLength > limits.maxBytes) throw new TypeError("JSON data exceeds its byte bound");
+	return snapshot;
+}
+function ownValue(source, key) {
+	const descriptor = Object.getOwnPropertyDescriptor(source, key);
+	if (descriptor === void 0) throw new TypeError("JSON arrays must not be sparse");
+	if (!("value" in descriptor)) throw new TypeError("JSON data must not use accessors");
+	return descriptor.value;
+}
+
+//#endregion
+//#region src/protocol/definition.ts
+/**
+* Stamp a protocol definition without allocating transport state or performing I/O.
+* All executable properties are captured once and retain the author's receiver.
+*/
+function defineWireProtocol(definition) {
+	const source = plainObject(definition, "wire protocol definition");
+	const id = boundedIdentifier(ownData(source, "id"), HTTP_PROTOCOL_LIMITS.idBytes, "protocol id");
+	const defaultDialect = snapshotJsonObject(ownData(source, "defaultDialect"), {
+		maxDepth: HTTP_PROTOCOL_LIMITS.dialectDepth,
+		maxNodes: HTTP_PROTOCOL_LIMITS.dialectNodes,
+		maxObjectFields: HTTP_PROTOCOL_LIMITS.dialectObjectFields,
+		maxArrayItems: HTTP_PROTOCOL_LIMITS.dialectArrayItems,
+		maxKeyBytes: HTTP_PROTOCOL_LIMITS.dialectKeyBytes,
+		maxBytes: HTTP_PROTOCOL_LIMITS.dialectBytes
+	});
+	const endpointPath = capturedMethod(source, "endpointPath");
+	const protocolHeaders = optionalCapturedMethod(source, "protocolHeaders");
+	const serialize = capturedMethod(source, "serialize");
+	const translate = capturedMethod(source, "translate");
+	return Object.freeze({
+		kind: "http-wire-protocol",
+		apiVersion: 1,
+		id,
+		defaultDialect,
+		endpointPath,
+		...protocolHeaders === void 0 ? {} : { protocolHeaders },
+		serialize,
+		translate
+	});
+}
+
+//#endregion
+//#region src/protocol/protocol.ts
+/**
+* Merge an endpoint's partial dialect over a protocol's defaults.
+*
+* `undefined` entries are dropped rather than applied, so an override object built
+* with optional fields cannot accidentally erase a default.
+* @param protocol - the protocol supplying defaults.
+* @param overrides - the endpoint's partial override.
+* @returns the effective, frozen dialect.
+*/
+function resolveDialect(protocol, overrides) {
+	if (overrides === void 0) return protocol.defaultDialect;
+	const applied = Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0));
+	return Object.freeze({
+		...protocol.defaultDialect,
+		...applied
+	});
+}
+
+//#endregion
+//#region src/observation/operations.ts
+const SAFE_OPERATION_ERROR_TYPES = /* @__PURE__ */ new Set([
+	"AbortError",
+	"AgentSdkError",
+	"CodexRefreshError",
+	"Error",
+	"ModelError",
+	"RangeError",
+	"TypeError"
+]);
+const SAFE_OPERATION_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ABORTED",
+	"CODEX_AUTH_FAILED",
+	"CODEX_AUTH_MALFORMED",
+	"CODEX_REAUTH_REQUIRED",
+	"CODEX_REFRESH_TRANSIENT",
+	"INVALID_CREDENTIAL",
+	"MISSING_CREDENTIAL",
+	"TIMEOUT"
+]);
+/** Observe one nested provider operation without exposing its sensitive values. */
+async function observeProviderOperation(context, input, task) {
+	const port = context?.observation;
+	const parent = context?.correlation;
+	const resource = context?.resource;
+	const scope = context?.scope;
+	if (port === void 0 || parent?.runId === void 0 || resource === void 0 || scope === void 0 || !isTraceId(parent.traceId) || !isSpanId(parent.spanId) || parent.parentSpanId !== null && !isSpanId(parent.parentSpanId)) return await task();
+	const correlationParent = parent;
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	let correlation = correlationParent;
+	let span;
+	try {
+		span = port.openSpan({
+			name: input.spanName,
+			runId: parent.runId,
+			parent: correlationParent,
+			startedAt,
+			monotonicMs: scope.monotonicMs()
+		});
+		correlation = span.correlation;
+	} catch {}
+	const capture = (phase, data) => {
+		const event = {
+			schemaVersion: 1,
+			eventId: createOperationId(),
+			sequence: scope.nextSequence(),
+			name: input.name,
+			phase,
+			occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+			monotonicMs: scope.monotonicMs(),
+			priority: "critical",
+			resource,
+			correlation,
+			data
+		};
+		try {
+			port.capture(event);
+		} catch {}
+	};
+	capture("start", input.data);
+	try {
+		const result = await task();
+		const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			span?.end("success", endedAt, scope.monotonicMs());
+		} catch {}
+		capture("end", {
+			...input.data,
+			status: "success"
+		});
+		return result;
+	} catch (error) {
+		const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+		try {
+			span?.end("error", endedAt, scope.monotonicMs());
+		} catch {}
+		const safe = safeErrorRecord(error);
+		const type = SAFE_OPERATION_ERROR_TYPES.has(safe.type) ? safe.type : "Error";
+		capture("end", {
+			...input.data,
+			status: "error",
+			error: {
+				type,
+				message: input.failureMessage,
+				...safe.code !== void 0 && SAFE_OPERATION_ERROR_CODES.has(safe.code) ? { code: safe.code } : {},
+				...safe.status === void 0 ? {} : { status: safe.status },
+				...safe.retryable === void 0 ? {} : { retryable: safe.retryable }
+			}
+		});
+		throw error;
+	}
+}
+function observeCredentialOperation(context, provider, operation, task) {
+	return observeProviderOperation(context, {
+		name: "sdk.credential.operation",
+		spanName: "sdk.credential.operation",
+		data: {
+			provider,
+			operation
+		},
+		failureMessage: "credential operation failed"
+	}, task);
+}
+function observeModelCatalogOperation(context, provider, origin, task) {
+	return observeProviderOperation(context, {
+		name: "sdk.integration.request",
+		spanName: "sdk.integration.request",
+		data: {
+			integration: "model-catalog",
+			provider,
+			operation: "discover",
+			origin
+		},
+		failureMessage: "model catalog operation failed"
+	}, task);
+}
+
+//#endregion
+//#region src/configurable/http-provider.ts
+const DEFAULT_CATALOG_TTL_MS = 3e5;
+const DEFAULT_CATALOG_STALE_TTL_MS = 0;
+const DEFAULT_CATALOG_FAILURE_BACKOFF_MS = 5e3;
+const DEFAULT_MAX_CATALOG_MODELS = 2048;
+const DEFAULT_MAX_CATALOG_BYTES = 4194304;
+/** Resolve one credential source, with a useful label on failure. */
+async function credential(source, displayName, label, signal, context) {
+	const value = typeof source === "function" ? await source(signal, context) : source;
+	return assertUsableApiKey(value, displayName, label);
+}
+/**
+* A provider whose every endpoint fact is configuration.
+*
+* Kept private: the exported surface is {@link createHttpProvider}, so this class
+* is free to change and callers cannot come to depend on its shape.
+*/
+var ConfiguredHttpAdapter = class extends HttpModelAdapter {
+	displayName;
+	options;
+	dialect;
+	retry;
+	catalog;
+	catalogFailureAt;
+	constructor(options) {
+		super();
+		const maxCatalogModels = positiveSafeInteger(options.maxCatalogModels ?? DEFAULT_MAX_CATALOG_MODELS, "maxCatalogModels");
+		const maxCatalogBytes = positiveSafeInteger(options.maxCatalogBytes ?? DEFAULT_MAX_CATALOG_BYTES, "maxCatalogBytes");
+		const models = options.models === void 0 ? void 0 : boundedCatalog(options.models, maxCatalogModels, maxCatalogBytes);
+		this.options = Object.freeze({
+			...options,
+			catalogTtlMs: positiveFinite(options.catalogTtlMs ?? DEFAULT_CATALOG_TTL_MS, "catalogTtlMs"),
+			catalogStaleTtlMs: nonNegativeFinite(options.catalogStaleTtlMs ?? DEFAULT_CATALOG_STALE_TTL_MS, "catalogStaleTtlMs"),
+			catalogFailureBackoffMs: nonNegativeFinite(options.catalogFailureBackoffMs ?? DEFAULT_CATALOG_FAILURE_BACKOFF_MS, "catalogFailureBackoffMs"),
+			maxCatalogModels,
+			maxCatalogBytes,
+			auth: Object.freeze({ ...options.auth }),
+			...models === void 0 ? {} : { models },
+			...options.headers === void 0 || typeof options.headers === "function" ? {} : { headers: Object.freeze({ ...options.headers }) },
+			...options.baseHeaders === void 0 ? {} : { baseHeaders: Object.freeze({ ...options.baseHeaders }) }
+		});
+		this.displayName = options.displayName;
+		this.dialect = resolveDialect(options.protocol, options.dialect);
+		this.retry = resolveRetryPolicy(options.retryPolicy, `${options.displayName}.retryPolicy`);
+	}
+	providerRetryPolicy() {
+		return this.retry;
+	}
+	listModels(provider, signal) {
+		if (!this.hasStaticCatalog()) return super.listModels(provider, signal);
+		signal?.throwIfAborted();
+		return Promise.resolve(this.staticModels(provider));
+	}
+	resolveModel(provider, model, signal) {
+		if (!this.hasStaticCatalog()) return super.resolveModel(provider, model, signal);
+		signal?.throwIfAborted();
+		return Promise.resolve(this.decorateModel(resolvedCatalogModelInfo(provider, model, this.options.models ?? [], this.options.defaultMaxTokens ?? 8192, this.options.defaultContextWindow ?? 128e3)));
+	}
+	async modelCatalog(provider, options = {}) {
+		if (this.hasStaticCatalog()) {
+			options.signal?.throwIfAborted();
+			return Object.freeze({
+				provider: Object.freeze({
+					id: provider,
+					name: this.displayName
+				}),
+				state: "static",
+				revision: "http-static",
+				models: this.staticModels(provider),
+				observedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		}
+		const snapshot = await super.modelCatalog(provider, options);
+		if (this.catalogFailureAt !== void 0) throw new Error("HTTP provider model catalog is unavailable");
+		return snapshot;
+	}
+	decorateModel(base) {
+		return this.options.describeModel?.(base, this.dialect) ?? base;
+	}
+	hasStaticCatalog() {
+		return this.options.models !== void 0 || this.options.discoverModels === void 0;
+	}
+	staticModels(provider) {
+		return Object.freeze((this.options.models ?? []).map((model) => Object.freeze(catalogModelInfo(provider, model))));
+	}
+	/** Resolve the authentication headers for one operation. */
+	async authHeaders(provider, signal, context) {
+		const auth = this.options.auth;
+		switch (auth.kind) {
+			case "none": return { headers: {} };
+			case "bearer": return { headers: { authorization: `Bearer ${await observeCredentialOperation(context, provider, "resolve", () => credential(auth.token, this.displayName, auth.label ?? "the `auth.token` option", signal, context))}` } };
+			case "header": {
+				const value = await observeCredentialOperation(context, provider, "resolve", () => credential(auth.value, this.displayName, auth.label ?? `the \`${auth.name}\` credential`, signal, context));
+				return { headers: { [auth.name]: value } };
+			}
+			case "dynamic": return { headers: await observeCredentialOperation(context, provider, "resolve", async () => await auth.resolve(signal, context, provider)) };
+			default: return { headers: {} };
+		}
+	}
+	async connect(provider, signal, context) {
+		const timeoutMs = positiveFinite(this.options.requestTimeoutMs ?? 6e5, "requestTimeoutMs");
+		const timeout = AbortSignal.timeout(timeoutMs);
+		const operationSignal = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+		const baseUrl = this.options.baseUrl.replace(/\/+$/, "");
+		const extra = typeof this.options.headers === "function" ? this.options.headers() : this.options.headers ?? {};
+		const publicLayers = [
+			captureHeaderLayer({
+				layer: "transport",
+				headers: this.options.baseHeaders ?? DEFAULT_TRANSPORT_HEADERS
+			}),
+			captureHeaderLayer({
+				layer: "sdk-attribution",
+				headers: attributionHeaders()
+			}),
+			captureHeaderLayer({
+				layer: "wire-protocol",
+				headers: this.options.protocol.protocolHeaders?.(this.dialect) ?? {}
+			}),
+			captureHeaderLayer({
+				layer: "endpoint",
+				headers: extra
+			})
+		];
+		mergeHeaderLayers(publicLayers);
+		const auth = await raceAbort(this.authHeaders(provider, operationSignal, context), operationSignal);
+		const merged = mergeHeaderLayers([...publicLayers, captureHeaderLayer({
+			layer: "auth",
+			headers: auth.headers
+		})]);
+		const headers = merged.headers;
+		return {
+			baseUrl,
+			headers,
+			sensitiveHeaderNames: merged.sensitiveHeaderNames,
+			streamIdleTimeoutMs: this.options.streamIdleTimeoutMs ?? 3e5,
+			requestTimeoutMs: this.options.requestTimeoutMs ?? 6e5,
+			maxRequestBytes: this.options.maxRequestBytes ?? 33554432,
+			maxResponseBytes: this.options.maxResponseBytes ?? 33554432,
+			maxResponseChunks: this.options.maxResponseChunks ?? 1e5,
+			...this.options.maxSseEvents === void 0 ? {} : { maxSseEvents: this.options.maxSseEvents },
+			...this.options.maxSseEventChars === void 0 ? {} : { maxSseEventChars: this.options.maxSseEventChars },
+			maxErrorBodyBytes: this.options.maxErrorBodyBytes ?? 1048576,
+			...this.options.allowInsecureHttp === void 0 ? {} : { allowInsecureHttp: this.options.allowInsecureHttp },
+			...this.options.fetch === void 0 ? {} : { fetch: this.options.fetch },
+			...this.options.requestLoggerTimeoutMs === void 0 ? {} : { requestLoggerTimeoutMs: this.options.requestLoggerTimeoutMs },
+			retryPolicy: this.retry,
+			models: this.options.models ?? await this.resolveCatalog(provider, baseUrl, headers, operationSignal, context),
+			defaultMaxTokens: this.options.defaultMaxTokens ?? 8192,
+			defaultContextWindow: this.options.defaultContextWindow ?? 128e3
+		};
+	}
+	/** Run the discovery hook, memoized, tolerating failure. */
+	async resolveCatalog(provider, baseUrl, headers, signal, context) {
+		const discover = this.options.discoverModels;
+		if (discover === void 0) return [];
+		const ttl = this.options.catalogTtlMs ?? DEFAULT_CATALOG_TTL_MS;
+		const staleTtl = this.options.catalogStaleTtlMs ?? DEFAULT_CATALOG_STALE_TTL_MS;
+		const failureBackoff = this.options.catalogFailureBackoffMs ?? DEFAULT_CATALOG_FAILURE_BACKOFF_MS;
+		const now = Date.now();
+		const cached = this.catalog;
+		if (cached !== void 0 && now - cached.fetchedAt < ttl) return cached.models;
+		if (this.catalogFailureAt !== void 0 && now - this.catalogFailureAt < failureBackoff) return staleCatalog(cached, now, ttl, staleTtl);
+		try {
+			const models = boundedCatalog(await observeModelCatalogOperation(context, provider, new URL(baseUrl).origin, async () => {
+				const pending = discover({
+					baseUrl,
+					headers,
+					provider,
+					...context === void 0 ? {} : { context },
+					...signal === void 0 ? {} : { signal }
+				});
+				return signal === void 0 ? await pending : await raceAbort(pending, signal);
+			}), this.options.maxCatalogModels ?? DEFAULT_MAX_CATALOG_MODELS, this.options.maxCatalogBytes ?? DEFAULT_MAX_CATALOG_BYTES);
+			this.catalog = {
+				models,
+				fetchedAt: Date.now()
+			};
+			this.catalogFailureAt = void 0;
+			return models;
+		} catch (error) {
+			if (signal?.aborted === true) throw signal.reason ?? error;
+			this.catalogFailureAt = Date.now();
+			return staleCatalog(cached, this.catalogFailureAt, ttl, staleTtl);
+		}
+	}
+	baseHeaders() {
+		return {};
+	}
+	observeRequest(record) {
+		return this.options.requestLogger?.(record);
+	}
+	providerErrorCode(status, detail) {
+		return this.options.errorCode?.(status, detail) ?? super.providerErrorCode(status, detail);
+	}
+	endpointPath(request) {
+		return this.options.protocol.endpointPath(request, this.dialect);
+	}
+	buildBody(request) {
+		return this.options.protocol.serialize(request, this.dialect);
+	}
+	translate(events, request) {
+		return this.options.protocol.translate(events, request, this.displayName);
+	}
+};
+function positiveFinite(value, field) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${field} must be a positive finite number`);
+	return value;
+}
+function positiveSafeInteger(value, field) {
+	if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${field} must be a positive safe integer`);
+	return value;
+}
+function nonNegativeFinite(value, field) {
+	if (!Number.isFinite(value) || value < 0) throw new RangeError(`${field} must be a non-negative finite number`);
+	return value;
+}
+function staleCatalog(cached, now, ttl, staleTtl) {
+	if (cached === void 0 || now - cached.fetchedAt >= ttl + staleTtl) return [];
+	return cached.models;
+}
+/** Validate resource bounds before retaining a provider-controlled catalog. */
+function boundedCatalog(value, maxModels, maxBytes) {
+	if (!Array.isArray(value)) throw new TypeError("model catalog must be an array");
+	if (value.length > maxModels) throw new RangeError(`model catalog exceeds maxCatalogModels (${maxModels})`);
+	let encoded;
+	try {
+		encoded = JSON.stringify(value);
+	} catch (error) {
+		throw new TypeError("model catalog must be JSON-serializable", { cause: error });
+	}
+	if (new TextEncoder().encode(encoded).byteLength > maxBytes) throw new RangeError(`model catalog exceeds maxCatalogBytes (${maxBytes})`);
+	return detachedFrozen(value);
+}
+function raceAbort(pending, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? /* @__PURE__ */ new Error("HTTP provider operation aborted"));
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			cleanup();
+			reject(signal.reason ?? /* @__PURE__ */ new Error("HTTP provider operation aborted"));
+		};
+		const cleanup = () => signal.removeEventListener("abort", abort);
+		signal.addEventListener("abort", abort, { once: true });
+		pending.then((value) => {
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			cleanup();
+			reject(error);
+		});
+	});
+}
+/**
+* Create a provider adapter from configuration.
+* @param options - protocol, endpoint, credential, and optional capability hooks.
+* @returns an adapter ready for `registry.registerAdapter`.
+*/
+function createHttpProvider(options) {
+	return new ConfiguredHttpAdapter(options);
+}
+
+//#endregion
+//#region src/common/wire-body.ts
+const WIRE_BODY_LIMITS = Object.freeze({
+	maxDepth: 64,
+	maxNodes: 2e5,
+	maxObjectFields: 1e5,
+	maxArrayItems: 1e5,
+	maxKeyBytes: 16384
+});
+/** Validate and detach one synchronous protocol JSON object before dispatch. */
+function snapshotWireBody(value, maxBytes) {
+	if (isThenable(value)) throw new ModelError("runtime wire protocol serialize() must return synchronously", HTTP_PROVIDER_ERROR_CODES.WIRE_BODY_INVALID);
+	try {
+		return snapshotJsonObject(value, {
+			...WIRE_BODY_LIMITS,
+			maxBytes
+		});
+	} catch (error) {
+		const tooLarge = error instanceof Error && /byte bound/.test(error.message);
+		throw new ModelError(tooLarge ? "runtime wire body exceeds maxRequestBytes" : "runtime wire body is not bounded JSON", tooLarge ? HTTP_PROVIDER_ERROR_CODES.WIRE_BODY_TOO_LARGE : HTTP_PROVIDER_ERROR_CODES.WIRE_BODY_INVALID, { cause: error });
+	}
+}
+function isThenable(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	const descriptor = Object.getOwnPropertyDescriptor(value, "then");
+	if (descriptor !== void 0 && !("value" in descriptor)) return true;
+	return descriptor !== void 0 && typeof descriptor.value === "function";
+}
+
+//#endregion
+//#region src/configurable/runtime-provider.ts
+const NEVER_ABORTED_SIGNAL = new AbortController().signal;
+const NULL_LOGGER = Object.freeze({
+	child: () => NULL_LOGGER,
+	trace: () => void 0,
+	debug: () => void 0,
+	info: () => void 0,
+	warn: () => void 0,
+	error: () => void 0,
+	fatal: () => void 0
+});
+/** Create the versioned HTTP extension adapter without performing credential or network I/O. */
+function createRuntimeHttpProvider(options) {
+	const source = plainObject(options, "runtime HTTP provider options");
+	const displayName = boundedIdentifier(ownData(source, "displayName"), 256, "displayName");
+	const baseUrl = captureBaseUrl(ownData(source, "baseUrl"));
+	const protocol = boundedRuntimeProtocol(captureRuntimeProtocol(ownData(source, "protocol")));
+	const auth = captureRuntimeAuth(ownData(source, "auth"), baseUrl);
+	const discover = optionalCapturedMethod(source, "discoverModels");
+	const fetch = optionalCapturedMethod(source, "fetch");
+	const describeModel = optionalCapturedMethod(source, "describeModel");
+	const errorCode = optionalCapturedMethod(source, "errorCode");
+	const requestLogger = optionalCapturedMethod(source, "requestLogger");
+	const headers = captureHeaders(source);
+	const legacy = {
+		displayName,
+		protocol,
+		baseUrl: baseUrl.href,
+		auth,
+		...copyOptional(source, "allowInsecureHttp"),
+		...copyJsonOptional(source, "models", "models"),
+		...copyJsonOptional(source, "dialect", "dialect"),
+		...fetch === void 0 ? {} : { fetch },
+		...headers === void 0 ? {} : { headers },
+		...copyOptional(source, "catalogTtlMs"),
+		...copyOptional(source, "catalogStaleTtlMs"),
+		...copyOptional(source, "catalogFailureBackoffMs"),
+		...copyOptional(source, "maxCatalogModels"),
+		...copyOptional(source, "maxCatalogBytes"),
+		...describeModel === void 0 ? {} : { describeModel },
+		...copyOptional(source, "defaultMaxTokens"),
+		...copyOptional(source, "defaultContextWindow"),
+		...copyOptional(source, "streamIdleTimeoutMs"),
+		...copyOptional(source, "requestTimeoutMs"),
+		...copyOptional(source, "maxRequestBytes"),
+		...copyOptional(source, "maxResponseBytes"),
+		...copyOptional(source, "maxResponseChunks"),
+		...copyOptional(source, "maxSseEvents"),
+		...copyOptional(source, "maxSseEventChars"),
+		...copyOptional(source, "maxErrorBodyBytes"),
+		...copyOptional(source, "requestLoggerTimeoutMs"),
+		...copyJsonOptional(source, "retryPolicy", "retryPolicy"),
+		...errorCode === void 0 ? {} : { errorCode },
+		...copyHeaderOptional(source, "baseHeaders", "transport"),
+		...requestLogger === void 0 ? {} : { requestLogger },
+		...discover === void 0 ? {} : { discoverModels: async (context) => discover({
+			provider: context.provider ?? "",
+			baseUrl: new URL(context.baseUrl),
+			headers: context.headers,
+			signal: context.signal ?? NEVER_ABORTED_SIGNAL,
+			...context.context === void 0 ? {} : { context: context.context }
+		}) }
+	};
+	return createHttpProvider(legacy);
+}
+function boundedRuntimeProtocol(protocol) {
+	return Object.freeze({
+		...protocol,
+		serialize(request, dialect) {
+			return snapshotWireBody(protocol.serialize(request, dialect), request.connection.maxRequestBytes ?? 33554432);
+		}
+	});
+}
+function captureRuntimeProtocol(value) {
+	try {
+		const source = plainObject(value, "runtime wire protocol");
+		if (ownData(source, "kind") !== "http-wire-protocol" || ownData(source, "apiVersion") !== 1) throw new TypeError("unsupported protocol marker");
+		const endpointPath = capturedMethod(source, "endpointPath");
+		const protocolHeaders = optionalCapturedMethod(source, "protocolHeaders");
+		const serialize = capturedMethod(source, "serialize");
+		const translate = capturedMethod(source, "translate");
+		return defineWireProtocol({
+			id: ownData(source, "id"),
+			defaultDialect: ownData(source, "defaultDialect"),
+			endpointPath,
+			...protocolHeaders === void 0 ? {} : { protocolHeaders },
+			serialize,
+			translate
+		});
+	} catch (error) {
+		throw new AgentSdkError("Runtime HTTP protocol is incompatible", HTTP_PROVIDER_ERROR_CODES.PROTOCOL_API_UNSUPPORTED, { cause: error });
+	}
+}
+function captureRuntimeAuth(value, baseUrl) {
+	const source = plainObject(value, "runtime HTTP auth");
+	const kind = ownData(source, "kind");
+	if (kind === "none") return Object.freeze({ kind });
+	if (kind === "bearer") return Object.freeze({
+		kind,
+		token: captureCredential(ownData(source, "token")),
+		...copyOptional(source, "label")
+	});
+	if (kind === "header") {
+		const name = boundedIdentifier(ownData(source, "name"), 256, "auth header name");
+		return Object.freeze({
+			kind,
+			name,
+			value: captureCredential(ownData(source, "value")),
+			...copyOptional(source, "label")
+		});
+	}
+	if (kind === "dynamic") {
+		const resolve = capturedMethod(source, "resolve");
+		return Object.freeze({
+			kind,
+			resolve: async (signal, context, provider = "") => ({ ...await resolve({
+				provider,
+				baseUrl,
+				signal: signal ?? NEVER_ABORTED_SIGNAL,
+				...context === void 0 ? {} : { context }
+			}) })
+		});
+	}
+	throw new AgentSdkError("Runtime HTTP auth is invalid", HTTP_PROVIDER_ERROR_CODES.HEADER_INVALID);
+}
+function captureCredential(input) {
+	if (typeof input === "string") return input;
+	const source = typeof input === "function" ? input : plainObject(input, "credential source");
+	if (ownData(source, "kind") !== "credential-source" || ownData(source, "apiVersion") !== CREDENTIAL_CAPABILITY_API_VERSION) throw new AgentSdkError("Credential source is incompatible", "CREDENTIAL_SOURCE_INVALID");
+	const resolve = capturedMethod(source, "resolve");
+	return (signal, context) => resolve({
+		signal: signal ?? NEVER_ABORTED_SIGNAL,
+		logger: context?.logger ?? NULL_LOGGER
+	});
+}
+function captureBaseUrl(value) {
+	if (value instanceof URL) return new URL(value.href);
+	if (typeof value === "string") return new URL(value);
+	throw new TypeError("baseUrl must be an absolute URL or URL string");
+}
+function copyOptional(source, key) {
+	const value = ownData(source, key, false);
+	return value === void 0 ? {} : { [key]: value };
+}
+function copyJsonOptional(source, key, envelopeKey) {
+	const value = ownData(source, key, false);
+	if (value === void 0) return {};
+	const snapshot = snapshotJsonObject({ [envelopeKey]: value }, HTTP_RUNTIME_OPTION_LIMITS);
+	return { [key]: snapshot[envelopeKey] };
+}
+function copyHeaderOptional(source, key, layer) {
+	const value = ownData(source, key, false);
+	return value === void 0 ? {} : { [key]: snapshotHeaders(value, layer) };
+}
+function captureHeaders(source) {
+	const value = ownData(source, "headers", false);
+	if (value === void 0) return void 0;
+	if (typeof value !== "function") return snapshotHeaders(value, "endpoint");
+	const captured = (...args) => Reflect.apply(value, source, args);
+	return () => snapshotHeaders(captured(), "endpoint");
+}
+function snapshotHeaders(value, layer) {
+	return mergeHeaderLayers([{
+		layer,
+		headers: value
+	}]).headers;
+}
+
+//#endregion
+//#region src/stream/sse.ts
+/**
+* Decode an SSE byte stream into events.
+*
+* All the genuinely hard framing work  Echunk reassembly, UTF-8 sequences split
+* across reads, CRLF and BOM handling, comment and unknown-field skipping,
+* joining multiple `data:` lines of one event  Ebelongs to `eventsource-parser`.
+*
+* Note what is deliberately NOT decided here. OpenAI terminates with a literal
+* `data: [DONE]` sentinel; Anthropic terminates with a named `message_stop` event
+* and sends no sentinel at all. Baking in either rule would make the parser lie
+* about the other, so termination is the adapter's call and this generator simply
+* runs to the end of the body.
+*
+* The callback-based parser is used rather than `EventSourceParserStream` so the
+* SDK does not require `TextDecoderStream` to exist  Eit is absent on some
+* runtimes this package should still work on.
+*
+* @module @alvin0/ai-agent-sdk-provider-http/sse
+*/
+/**
+* Parse an SSE byte stream into events, in arrival order.
+*
+* Framing is spec-strict: an event dispatches only on its blank-line terminator,
+* so an unterminated tail at EOF is truncation rather than a flushable payload.
+* @param stream - raw SSE bytes, as `Response.body` provides them. Reads may split
+*   anywhere, including mid-codepoint; the streaming decoder handles that.
+* @param onActivity - called on every frame INCLUDING comments. Providers send
+*   comment-only keepalives during long pauses, so a liveness watchdog has to
+*   count them as activity even though they carry no data.
+* @returns each event in arrival order; returns normally at end of body.
+*/
+async function* parseSse(stream, onActivity, teardownTimeoutMs = DEFAULT_SSE_TEARDOWN_TIMEOUT_MS) {
+	yield* parseSseBounded(stream, onActivity, teardownTimeoutMs, {
+		maxEvents: DEFAULT_MAX_SSE_EVENTS,
+		maxEventChars: DEFAULT_MAX_SSE_EVENT_CHARS
+	});
+}
+
+//#endregion
+export { DEFAULT_MAX_ERROR_BODY_BYTES, DEFAULT_MAX_REQUEST_BYTES, DEFAULT_MAX_RESPONSE_BYTES, DEFAULT_MAX_RESPONSE_CHUNKS, DEFAULT_REQUEST_LOGGER_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, HTTP_PROTOCOL_API_VERSION, HTTP_PROVIDER_ERROR_CODES, HttpModelAdapter, createHttpProvider, createRuntimeHttpProvider, defineWireProtocol, httpErrorCode, observeCredentialOperation, observeModelCatalogOperation, parseErrorBody, parseSse, redactHeaders, requestIdFrom, resolveDialect, retryAfterMs };
+//# sourceMappingURL=index.js.map