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

package/dist/index.js

@@ -1,6 +1,7 @@
-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 { CONTEXT_WINDOW_EXCEEDED_CODE, MODEL_ERROR_CODES, ModelAdapter, ModelError, ProviderRequestId, QUOTA_EXCEEDED_CODE, assertUsableApiKey, attributionHeaders, contentHasDocument, 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";
+import { unknownEmbeddingModel } from "@alvin0/ai-agent-sdk-core/embedding";
 
 //#region src/common/config.ts
 /** Runtime wire-protocol contract version supported by this package. */
@@ -14,6 +15,7 @@ const HTTP_PROVIDER_ERROR_CODES = Object.freeze({
 	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",
+	JSON_MEDIA_TYPE_INVALID: "HTTP_JSON_MEDIA_TYPE_INVALID",
 	SSE_LIMIT_EXCEEDED: "HTTP_SSE_LIMIT_EXCEEDED",
 	REDIRECT_REJECTED: "HTTP_REDIRECT_REJECTED"
 });
@@ -216,83 +218,6 @@ async function* requireTerminalFinish(source, displayName) {
 	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({
@@ -379,122 +304,122 @@ function headerError(message, key) {
 }
 
 //#endregion
-//#region src/base/http-errors.ts
+//#region src/transport/connection.ts
 /**
-* The HTTP-to-taxonomy mapping every provider shares.
+* The connection snapshot every HTTP pipeline in this package 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.
+* The snapshot exists to close a specific gap: if the endpoint and the credential
+* were read separately, a configuration change between the two reads would send
+* one generation's secret to another generation's URL. Reading them together, once
+* per operation, makes that impossible.
 *
-* @module ai-agent-sdk/providers/base/http-errors
-*/
-/**
-* Map an HTTP status plus whatever the provider said into a stable code.
+* What lives here is only what a request needs regardless of what comes back:
+* where to send it, with what credentials, under what bounds, and with which retry
+* policy. A pipeline's own vocabulary stays with the pipeline — the generation
+* catalog is on {@link ../base/http-adapter.HttpConnection}, and the embedding
+* catalog will be on its own extension, because merging the two catalogs is
+* exactly the mistake that makes one model shape stand in for another.
 *
-* `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.
+* @module ai-agent-sdk/providers/transport/connection
 */
-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.
+* Merge the transport's own header layer beneath the snapshot's auth layer, once.
 *
-* 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.
+* Layer ownership is what makes this safe to call on a snapshot a subclass or a
+* configuration produced: a transport header can never silently overwrite a
+* credential, and the names the auth layer marked sensitive survive the merge so
+* redaction still covers them.
 *
-* 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`.
+* A snapshot that already carries every layer — which configured adapters return —
+* passes an empty transport layer and is returned untouched, so capturing twice
+* cannot re-apply attribution.
+* @param connection - the snapshot captured for this operation.
+* @param transportHeaders - the transport layer to merge underneath; may be empty.
+* @returns the snapshot with merged headers and the union of sensitive names.
 */
-function requestIdFrom(headers) {
-	for (const name of REQUEST_ID_HEADERS) {
-		const value = headers.get(name);
-		if (value !== null && value.length > 0) return ProviderRequestId(value);
-	}
+function captureTransportConnection(connection, transportHeaders) {
+	if (Reflect.ownKeys(transportHeaders).length === 0) return connection;
+	const merged = mergeHeaderLayers([
+		{
+			layer: "transport",
+			headers: transportHeaders
+		},
+		{
+			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])])
+	});
 }
-/** 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;
+
+//#endregion
+//#region src/transport/limits.ts
+/** 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;
+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;
 }
 /**
-* Reduce a provider error body to a message and a classifier detail string.
+* Apply defaults and reject nonsense bounds before any I/O happens.
 *
-* 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.
+* Validation order is fixed and part of the contract: a configuration with two
+* invalid bounds always reports the earlier field, so the error a caller sees does
+* not depend on which limit the pipeline happens to consult first.
+* @param connection - the captured snapshot this request is bound to.
+* @returns fully resolved bounds; never partially defaulted.
 */
-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(" ")
-	};
+function resolveTransportLimits(connection) {
+	return Object.freeze({
+		requestTimeoutMs: positiveFinite$1(connection.requestTimeoutMs ?? 6e5, "requestTimeoutMs"),
+		maxRequestBytes: positiveInteger(connection.maxRequestBytes ?? 33554432, "maxRequestBytes"),
+		maxResponseBytes: positiveInteger(connection.maxResponseBytes ?? 33554432, "maxResponseBytes"),
+		maxResponseChunks: positiveInteger(connection.maxResponseChunks ?? 1e5, "maxResponseChunks"),
+		maxErrorBodyBytes: positiveInteger(connection.maxErrorBodyBytes ?? 1048576, "maxErrorBodyBytes"),
+		requestLoggerTimeoutMs: positiveFinite$1(connection.requestLoggerTimeoutMs ?? 5e3, "requestLoggerTimeoutMs")
+	});
 }
 
 //#endregion
-//#region src/base/transport.ts
+//#region src/transport/http.ts
+/**
+* The pipeline-independent HTTP primitives the shared chain is built from.
+*
+* Each one exists because the obvious version of it is wrong in a way that only
+* shows up under failure: a body read without a byte bound is a memory bug waiting
+* for a hostile response, a promise raced against a signal that disposes nothing
+* leaks a socket, a redirect followed once is a credential sent somewhere the
+* caller never named, and an iterator abandoned without `return()` leaves a reader
+* locked forever.
+*
+* None of it knows anything about SSE, JSON, catalogs, or model shapes — which is
+* why it sits under the transport and not beside a pipeline.
+*
+* @module ai-agent-sdk/providers/transport/http
+*/
+/** Bound a response body by cumulative bytes and by chunk count, whichever trips first. */
 function boundedResponseBody(source, maxBytes, maxChunks, displayName, signal) {
 	let bytes = 0;
 	let chunks = 0;
@@ -506,6 +431,7 @@ function boundedResponseBody(source, maxBytes, maxChunks, displayName, signal) {
 		controller.enqueue(chunk);
 	} }), signal === void 0 ? void 0 : { signal });
 }
+/** Read at most `maxBytes` of text, marking the truncation in the returned string. */
 async function readBoundedText(response, maxBytes, signal) {
 	if (response.body === null) return "";
 	const reader = response.body.getReader();
@@ -543,6 +469,7 @@ async function rejectProviderRedirect(response, requestedUrl) {
 	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 });
 }
+/** Await a promise but surrender as soon as the signal aborts. */
 async function raceWithSignal(pending, signal) {
 	if (signal.aborted) {
 		pending.catch(() => void 0);
@@ -570,6 +497,7 @@ async function cancelResponseBody(response) {
 		await waitForSettlement(Promise.resolve().then(() => response.body.cancel()), 3e4);
 	} catch {}
 }
+/** Iterate an async source under a signal, closing the iterator when it is cut short. */
 async function* withAbortSignal(iterable, signal) {
 	const iterator = iterable[Symbol.asyncIterator]();
 	let exhausted = false;
@@ -594,49 +522,501 @@ async function* withAbortSignal(iterable, signal) {
 		}
 	}
 }
-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;
+/** Join a base URL and a path while refusing credentials, cleartext, and origin escapes. */
+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;
+}
+/** Reduce a failure to what a support report may carry: a code, a status, no prose. */
+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 }
+	});
+}
+/** Replace credential-bearing header values, by provenance and by name shape. */
+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]));
+}
+/** Local correlation id for a diagnostic record, without requiring a crypto global. */
+function requestLogId() {
+	return globalThis.crypto?.randomUUID?.() ?? `request-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** The one shape a caller-requested cancellation takes on the way out. */
+function abortError(displayName, cause) {
+	return new ModelError(`${displayName} request aborted by caller`, MODEL_ERROR_CODES.ABORTED, { cause });
+}
+
+//#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/transport/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.
+*
+* It lives in the transport rather than beside the generation pipeline because
+* every pipeline maps the same statuses the same way; the SSE half of generation
+* has no opinion about what a 429 means.
+*
+* @module ai-agent-sdk/providers/transport/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;
 }
-function endpointUrl(baseUrl, path, allowInsecureHttp) {
-	let base;
+/**
+* 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 {
-		base = new URL(baseUrl);
-	} catch (error) {
-		throw new ModelError("provider baseUrl is not a valid absolute URL", MODEL_ERROR_CODES.INVALID_REQUEST, { cause: error });
+		parsed = JSON.parse(raw);
+	} catch {
+		return {
+			message: void 0,
+			detail: raw.slice(0, 2048)
+		};
 	}
-	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;
+	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/transport/session.ts
+/**
+* The one risky chain every HTTP pipeline in this package runs, written once.
+*
+* Everything here is a step that is invisible when it works and expensive when it
+* is missing: fusing the caller's cancellation with our own teardown controller and
+* the request deadline, bounding the outbound body, letting a diagnostic observer
+* look at the request without letting it veto dispatch, opening a provider attempt
+* before the socket and closing it exactly once afterwards, refusing a redirect
+* instead of replaying credentials to wherever it points, turning a non-2xx into a
+* stable code with `retry-after` and a request id attached, and releasing the
+* response body when the consumer walks away early.
+*
+* A second copy of this chain for embedding would be a second chance to forget one
+* of those steps — which is precisely why the chain, and not the decoding, is what
+* gets shared. What a pipeline supplies is only `decode`: what to do with a
+* response that already passed every guard above.
+*
+* The classification order at the bottom is part of the contract and is deliberately
+* not simplified: a fired deadline outranks an abort the caller did not request,
+* an aborted fused signal outranks a transport failure, and an admission refusal
+* from `startProviderAttempt` is rethrown untouched so audit mode's decision is not
+* relabelled as a transport error.
+*
+* @module ai-agent-sdk/providers/transport/session
+*/
+/**
+* Run one request through the shared safety chain and stream `use`'s output.
+*
+* The generator shape matters: the provider attempt stays open, and the response
+* body stays owned, for as long as the consumer keeps pulling. A consumer that
+* stops early aborts the teardown controller in `finally`, which is what tears down
+* an in-flight response instead of leaking the connection.
+* @param input - the request facts, all captured from one connection snapshot.
+* @param use - decodes a guarded response; its failures are classified here.
+* @returns whatever `use` yields, unchanged.
+*/
+async function* withTransportSession(input, use) {
+	const { connection, context, displayName, model, provider } = input;
+	const callerSignal = input.signal;
+	const consumer = new AbortController();
+	const limits = resolveTransportLimits(connection);
+	const timeout = AbortSignal.timeout(limits.requestTimeoutMs);
+	const signal = AbortSignal.any([
+		consumer.signal,
+		timeout,
+		...callerSignal === void 0 ? [] : [callerSignal]
+	]);
+	let admissionFailure;
+	let ownedResponse;
 	try {
-		endpoint = new URL(`${normalizedBase}${path}`);
+		signal.throwIfAborted();
+		const preparedBody = typeof input.body === "function" ? await input.body(signal) : input.body;
+		if (preparedBody.bytes > limits.maxRequestBytes) throw new ModelError(`${displayName} request exceeds the ${limits.maxRequestBytes}-byte limit`, MODEL_ERROR_CODES.INVALID_REQUEST);
+		const endpoint = endpointUrl(connection.baseUrl, input.path, connection.allowInsecureHttp ?? false);
+		const url = endpoint.href;
+		const origin = endpoint.origin;
+		const headers = connection.headers;
+		try {
+			const loggerSignal = AbortSignal.any([signal, AbortSignal.timeout(limits.requestLoggerTimeoutMs)]);
+			await raceWithSignal(Promise.resolve(input.observeRequest?.({
+				schemaVersion: 1,
+				type: "provider-request",
+				id: requestLogId(),
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				provider,
+				model,
+				method: "POST",
+				url,
+				headers: redactHeaders(headers, connection.sensitiveHeaderNames),
+				body: preparedBody.value,
+				bodyBytes: preparedBody.bytes
+			})), loggerSignal);
+		} catch {}
+		let attempt;
+		let dispatchState = "not-sent";
+		let httpStatus;
+		let providerRequestId;
+		let attemptStatus = "unknown";
+		let attemptUsage;
+		let usageFinal = true;
+		let attemptError;
+		try {
+			signal.throwIfAborted();
+			try {
+				attempt = await context?.startProviderAttempt?.({
+					provider,
+					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: preparedBody.encoded,
+				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 httpFailure(response, origin, limits.maxErrorBodyBytes, signal, input);
+			yield* use(Object.freeze({
+				response,
+				url,
+				origin,
+				signal,
+				accept: input.accept,
+				limits,
+				...providerRequestId === void 0 ? {} : { providerRequestId },
+				reportUsage(usage, final = true) {
+					attemptUsage = usage;
+					usageFinal = final;
+				},
+				...attempt === void 0 ? {} : { attemptId: attempt.attemptId },
+				reportOutcome(status, failure) {
+					attemptStatus = status;
+					if (failure !== void 0) attemptError = safeProviderFailure(failure);
+				}
+			}));
+		} catch (error) {
+			if (admissionFailure !== void 0 && error === admissionFailure.value) throw error;
+			const mapped = timeout.aborted && callerSignal?.aborted !== true ? new ModelError(`${displayName} request exceeded its ${limits.requestTimeoutMs}ms time limit`, MODEL_ERROR_CODES.TIMEOUT, { cause: error }) : signal.aborted ? abortError(displayName, error) : normalizeHttpBoundaryError(error, `${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 },
+				...usageFinal ? {} : { usageFinal: false },
+				...httpStatus === void 0 ? {} : { httpStatus },
+				...providerRequestId === void 0 ? {} : { providerRequestId },
+				...attemptError === void 0 ? {} : { error: attemptError }
+			});
+		}
 	} catch (error) {
-		throw new ModelError("provider endpoint path produced an invalid URL", MODEL_ERROR_CODES.INVALID_REQUEST, { cause: error });
+		if (callerSignal?.aborted === true) throw abortError(displayName, error);
+		if (timeout.aborted) throw new ModelError(`${displayName} request exceeded its ${limits.requestTimeoutMs}ms time limit`, MODEL_ERROR_CODES.TIMEOUT, { cause: error });
+		if (admissionFailure !== void 0 && error === admissionFailure.value) throw error;
+		throw normalizeHttpBoundaryError(error, `${displayName} stream failed`);
+	} finally {
+		consumer.abort(/* @__PURE__ */ new Error(`${displayName} stream consumer stopped`));
+		if (ownedResponse !== void 0) await cancelResponseBody(ownedResponse);
 	}
-	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 }
+/**
+* Turn a non-2xx response into a fully populated {@link ModelError}.
+*
+* The body is read under the same bound and the same signal as everything else,
+* and a body that cannot be read does not replace the status — the status is the
+* more reliable signal of the two anyway.
+* @param response - the non-success response.
+* @param origin - request origin, reported in the message instead of the full URL.
+* @param maxBytes - error-body bound from the resolved limits.
+* @param signal - the fused signal.
+* @param input - request facts, for the display name and code override.
+* @returns the mapped error, carrying status, `retry-after`, and request id.
+*/
+async function httpFailure(response, origin, maxBytes, signal, input) {
+	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 ?? `${input.displayName} error (HTTP ${response.status}) from ${origin}`, (input.errorCode ?? httpErrorCode)(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 }
 	});
 }
-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]));
+
+//#endregion
+//#region src/transport/stream.ts
+/**
+* The streaming pipeline's entry into the shared transport chain.
+*
+* Two properties define it, and both are about what happens while a consumer is
+* still pulling. The provider attempt stays open for the whole stream, because a
+* stream that fails halfway through is one attempt with a failure — not a success
+* followed by a mystery. And every pull is raced against the fused signal, so a
+* decoder that blocks on a provider which has stopped sending still surrenders when
+* the caller aborts, the deadline fires, or the consumer walks away.
+*
+* What `decode` sees is a response that already cleared every guard in
+* {@link withTransportSession}: bounded body, no redirect, 2xx, attempt open. What
+* it owns is the format — media type, framing, termination.
+*
+* @module ai-agent-sdk/providers/transport/stream
+*/
+/**
+* Send one request and stream whatever `decode` makes of the response.
+*
+* @param input - request facts captured from one connection snapshot.
+* @param decode - turns a guarded response into the pipeline's own values.
+* @returns the decoded values, with the attempt held open until iteration ends.
+*/
+function transportStream(input, decode) {
+	return withTransportSession(input, (session) => withAbortSignal(decode(session), session.signal));
 }
-function requestLogId() {
-	return globalThis.crypto?.randomUUID?.() ?? `request-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+
+//#endregion
+//#region src/base/context-policy.ts
+function applyModelContextPolicy(info, policy, configured, providerOverride) {
+	const defaultContextWindow = configured?.defaultContextWindow ?? policy?.defaultContextWindow ?? info.context?.defaultContextWindow;
+	const knownMaximum = policy?.maxContextWindow ?? info.context?.maxContextWindow;
+	const maxContextWindow = knownMaximum === void 0 ? configured?.maxContextWindow : Math.min(knownMaximum, configured?.maxContextWindow ?? knownMaximum);
+	const standardPriceInputTokens = configured?.standardPriceInputTokens ?? policy?.standardPriceInputTokens ?? info.context?.standardPriceInputTokens;
+	const contextWindow = configured?.contextWindow ?? providerOverride ?? defaultContextWindow ?? info.context?.contextWindow;
+	for (const [name, value] of Object.entries({
+		contextWindow,
+		defaultContextWindow,
+		maxContextWindow,
+		standardPriceInputTokens
+	})) if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) throw new TypeError(`${name} must be a positive safe integer`);
+	if (maxContextWindow !== void 0 && (contextWindow !== void 0 && contextWindow > maxContextWindow || defaultContextWindow !== void 0 && defaultContextWindow > maxContextWindow)) throw new RangeError("contextWindow exceeds maxContextWindow");
+	if (contextWindow === void 0) return info;
+	return {
+		...info,
+		context: {
+			contextWindow,
+			...defaultContextWindow === void 0 ? {} : { defaultContextWindow },
+			...maxContextWindow === void 0 ? {} : { maxContextWindow },
+			...standardPriceInputTokens === void 0 ? {} : { standardPriceInputTokens },
+			...standardPriceInputTokens !== void 0 && contextWindow > standardPriceInputTokens ? { pricingWarning: "extended-context-may-cost-more" } : {}
+		}
+	};
 }
+/** Capture configuration so later caller mutations cannot change model resolution. */
+function createModelContextPolicy(policies, models, providerOverride) {
+	const captured = structuredClone(policies);
+	const configured = structuredClone(models ?? []);
+	return (info) => applyModelContextPolicy(info, Object.hasOwn(captured, info.id) ? captured[info.id] : void 0, configured.find((model) => model.id === info.id), providerOverride);
+}
+
+//#endregion
+//#region src/base/transport.ts
 function catalogModelInfo(provider, model) {
 	return {
 		provider,
@@ -651,7 +1031,7 @@ function catalogModelInfo(provider, model) {
 /** 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 {
+	return applyModelContextPolicy({
 		...configured === void 0 ? {
 			provider,
 			id: modelId,
@@ -659,14 +1039,11 @@ function resolvedCatalogModelInfo(provider, modelId, models, defaultMaxTokens, d
 			inputModalities: ["text"]
 		} : catalogModelInfo(provider, configured),
 		context: { contextWindow: configured?.contextWindow ?? defaultContextWindow },
-		defaultMaxTokens: configured?.maxTokens ?? defaultMaxTokens,
-		maxOutputTokens: configured?.maxTokens ?? defaultMaxTokens,
+		defaultMaxTokens: configured?.defaultMaxTokens ?? configured?.maxTokens ?? defaultMaxTokens,
+		...configured?.maxTokens === void 0 ? {} : { maxOutputTokens: configured.maxTokens },
 		...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 });
+	}, void 0, configured);
 }
 
 //#endregion
@@ -689,22 +1066,33 @@ function abortError(displayName, cause) {
 * request, HTTP error mapping, `retry-after`, request ids, SSE decoding, the idle
 * bound, and teardown — is shared and happens exactly once, here.
 *
+* The risky half of that list — signal fusion, request bounds, the diagnostic
+* observer, attempt accounting, redirect refusal, status mapping, teardown — now
+* lives in {@link ../transport/session.withTransportSession} so a second pipeline
+* cannot reimplement it slightly differently. What stays in this file is what is
+* genuinely generation's: the modality guard, the catalog, the serialized-body
+* cache for one prepared call, and {@link HttpModelAdapter.decodeSse} — the SSE
+* half, unchanged, applied to a response that already cleared every guard.
+*
 * @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;
+/**
+* Resolve the SSE bounds before any transport work starts.
+*
+* Deliberately validated in the pipeline and not inside `decodeSse`: an
+* unusable bound is a configuration error, and configuration errors must not
+* arrive after a provider attempt has been opened and a request sent.
+* @param connection - the snapshot this call is bound to.
+* @returns defaulted, validated event bounds.
+*/
+function resolveSseLimits(connection) {
+	return Object.freeze({
+		maxEvents: positiveInteger(connection.maxSseEvents ?? 1e5, "maxSseEvents"),
+		maxEventChars: positiveInteger(connection.maxSseEventChars ?? 1048576, "maxSseEventChars")
+	});
+}
 /** Base for every HTTP provider adapter in this package. */
 var HttpModelAdapter = class extends ModelAdapter {
 	/**
@@ -781,204 +1169,115 @@ var HttpModelAdapter = class extends ModelAdapter {
 	}
 	/** 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])])
-		});
+		return captureTransportConnection(connection, this.baseHeaders());
 	}
 	/**
-	* The shared pipeline: guard, build, send, classify, decode, bound, translate.
+	* The generation pipeline: guard the modalities, then hand one request to the
+	* shared transport chain with SSE decoding as its only pipeline-specific part.
+	*
+	* Still a generator, and deliberately so: the modality guard, the body
+	* serialization and every transport step stay lazy until a consumer pulls, which
+	* is the behaviour every existing caller of `stream()` already relies on.
 	*/
 	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);
+		if (options.messages.some((message) => contentHasDocument(message.content)) && model.inputModalities?.includes("document") !== true) throw new ModelError(`${this.displayName} model "${options.model}" does not accept document 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 }
-				});
+		const sseLimits = resolveSseLimits(connection);
+		const adapter = this;
+		yield* transportStream({
+			connection,
+			displayName: this.displayName,
+			provider: options.provider,
+			model: options.model,
+			accept: "text/event-stream",
+			/**
+			* Read by the transport AFTER the body is prepared, which is exactly where
+			* the pipeline used to call it. A provider whose path computation fails
+			* therefore still fails inside the transport's classification, and a
+			* protocol that reports its routing decision from `endpointPath` still
+			* reports it once, in the same place in the sequence, as before.
+			*/
+			get path() {
+				return adapter.endpointPath(request);
+			},
+			body: (signal) => wireBodyCache.prepared ??= this.prepareWireBody(request, signal),
+			...options.signal === void 0 ? {} : { signal: options.signal },
+			...context === void 0 ? {} : { context },
+			errorCode: (status, detail) => this.providerErrorCode(status, detail),
+			observeRequest: (record) => this.observeRequest(record)
+		}, (session) => this.decodeSse(session, request, sseLimits));
+	}
+	/**
+	* The SSE half: media type, bounds, idle deadline, translation, usage honesty.
+	*
+	* Everything this sees has already cleared the transport's guards — 2xx, no
+	* redirect, attempt open, teardown owned — so what remains is only the format.
+	* Abort racing is not repeated here: {@link transportStream} already iterates
+	* this generator under the fused signal.
+	* @param session - the guarded response and its attempt-evidence hooks.
+	* @param request - the request this response answers.
+	* @param sse - event bounds resolved before any transport work began.
+	* @returns the provider's chunks, with incomplete usage held back.
+	*/
+	async *decodeSse(session, request, sse) {
+		const response = session.response;
+		if (response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== session.accept) 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 maxResponseBytes = session.limits.maxResponseBytes;
+		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(request.connection.streamIdleTimeoutMs, this.displayName, 3e4);
+		const events = parseSseBounded(boundedResponseBody(response.body, maxResponseBytes, session.limits.maxResponseChunks, this.displayName, session.signal), idleDeadline.activity, 3e4, {
+			maxEvents: sse.maxEvents,
+			maxEventChars: sse.maxEventChars
+		});
+		const translated = requireTerminalFinish(this.translate(events, request), this.displayName);
+		for await (const chunk of idleDeadline.guard(translated)) {
+			if (chunk.type === "usage-progress") {
+				session.reportUsage(chunk.usage, false);
+				const validated = validateUsageCounters(chunk.usage, true);
+				if (Object.keys(validated.reported).length > 0) yield {
+					type: "usage-progress",
+					usage: validated.reported,
+					...session.attemptId === void 0 ? {} : { attemptId: session.attemptId }
+				};
+				continue;
 			}
-		} 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);
+			if (chunk.type === "usage") {
+				session.reportUsage(chunk.usage);
+				const validated = validateUsageCounters(chunk.usage, true);
+				if (!validated.complete) continue;
+				yield {
+					type: "usage",
+					usage: validated.reported
+				};
+				continue;
+			}
+			if (chunk.type === "finish") {
+				const status = chunk.reason.kind === "aborted" ? "aborted" : chunk.reason.kind === "error" ? "error" : "success";
+				session.reportOutcome(status, chunk.reason.kind === "error" || chunk.reason.kind === "aborted" ? chunk.reason.failure : void 0);
+			}
+			yield chunk;
 		}
 	}
-	async prepareWireBody(request, maxRequestBytes, signal) {
+	async prepareWireBody(request, 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
@@ -1753,5 +2052,206 @@ async function* parseSse(stream, onActivity, teardownTimeoutMs = DEFAULT_SSE_TEA
 }
 
 //#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 };
+//#region src/transport/embedding-connection.ts
+/**
+* Embedding's half of a connection snapshot, plus the one translation from a
+* declared route catalog into `Embedding_Catalog` capabilities.
+*
+* This module sits on top of {@link HttpTransportConnection} rather than inside
+* it: the transport and the JSON pipeline know nothing about embedding
+* vocabulary, and they must not, or a second pipeline could not exist without
+* dragging the first one's catalog along. What embedding adds is a catalog with
+* its own semantics — vector widths, batch ceilings, purpose handling, and a
+* declaration about which embedding space the vectors belong to.
+*
+* The translation rule has exactly one shape and it runs in one direction: a
+* field the configuration DECLARES becomes `supported`, a field it OMITS becomes
+* `unknown` (Requirement 10.5). Nothing here manufactures a `supported` value
+* from a default, because a default is the SDK's opinion, not the route's claim,
+* and `unknown` is never a reason to reject a request.
+*
+* Two things are deliberately NOT here:
+*
+*  - Cleartext HTTP handling. `EmbeddingHttpConnection` extends the transport
+*    snapshot, so `allowInsecureHttp` is the same field the same `endpointUrl()`
+*    already enforces for generation — a self-hosted `http://` endpoint is
+*    rejected unless the caller opts in explicitly, and embedding gets that for
+*    free rather than through a second copy of the rule (Requirement 15.5).
+*  - The generation catalog. `models`, `defaultMaxTokens` and
+*    `defaultContextWindow` stay on `HttpConnection`; folding the two catalogs
+*    into one shape is the conflation Requirement 10.1 rules out.
+*
+* @module ai-agent-sdk/providers/transport/embedding-connection
+*/
+/** The `unknown` capability, shared so translations need not re-allocate it. */
+const UNKNOWN = Object.freeze({ state: "unknown" });
+/** The `unsupported` capability, for a route's positive negative claim. */
+const UNSUPPORTED = Object.freeze({ state: "unsupported" });
+/** Declared value becomes `supported`; omission stays `unknown`. */
+function declared(value) {
+	return value === void 0 ? UNKNOWN : Object.freeze({
+		state: "supported",
+		value
+	});
+}
+/** The one place `'unsupported'` is separated from an omitted declaration. */
+function declaredPurpose(value) {
+	if (value === void 0) return UNKNOWN;
+	return value === "unsupported" ? UNSUPPORTED : Object.freeze({
+		state: "supported",
+		value
+	});
+}
+/**
+* Translate one declared catalog entry into `Embedding_Catalog` metadata.
+*
+* `inputTypes` and `representation` come out `unknown` rather than filled in
+* from the v1 scope: the scope is already readable from the types
+* (`EmbeddingInputType` is `'text'`, `EmbeddingRepresentation` is
+* `'dense-float32'`), and stating `supported` on the route's behalf would be
+* the SDK asserting a claim the route never made.
+* @param provider - route that owns the entry.
+* @param model - the declared catalog entry.
+* @returns advisory embedding metadata for this entry.
+*/
+function embeddingCatalogModelInfo(provider, model) {
+	return {
+		provider,
+		id: model.id,
+		name: model.name ?? model.id,
+		...model.description === void 0 ? {} : { description: model.description },
+		inputTypes: UNKNOWN,
+		representation: UNKNOWN,
+		dimensions: declared(model.dimensions),
+		defaultDimensions: declared(model.defaultDimensions),
+		maxInputTokens: declared(model.maxInputTokens),
+		maxBatchItems: declared(model.maxBatchItems),
+		maxBatchTokens: declared(model.maxBatchTokens),
+		maxBatchBytes: declared(model.maxBatchBytes),
+		purposeHandling: declaredPurpose(model.purposeHandling),
+		normalization: declared(model.normalization),
+		compatibilityIdentity: declared(model.compatibilityIdentity)
+	};
+}
+/**
+* Resolve exact embedding metadata for a model id from an advisory catalog.
+*
+* An id the catalog does not describe stays usable: the caller gets an
+* identity-only descriptor with every capability `unknown` and the provider
+* decides (Requirement 10.3). The catalog restricting the request would make
+* membership authoritative, which it is not.
+* @param provider - route being resolved.
+* @param modelId - requested model id.
+* @param models - the route's declared catalog.
+* @returns exact metadata for the id, or the identity-only descriptor.
+*/
+function resolvedEmbeddingCatalogModelInfo(provider, modelId, models) {
+	const configured = models.find((entry) => entry.id === modelId);
+	if (configured === void 0) return unknownEmbeddingModel(provider, modelId);
+	return embeddingCatalogModelInfo(provider, configured);
+}
+
+//#endregion
+//#region src/transport/json.ts
+/**
+* The JSON pipeline's entry into the shared transport chain.
+*
+* Where the streaming pipeline keeps a provider attempt open for as long as a
+* consumer keeps pulling, this one has a single, bounded shape: read the whole body
+* under the configured byte and chunk bounds, parse it, hand the parsed value to
+* `decode`, close the attempt. There is no framing to track and no idle deadline to
+* enforce, because there is nothing to wait for between events.
+*
+* Three failures are stated rather than inferred, since each one has a
+* plausible-looking wrong answer:
+*
+* - A response whose media type is not JSON is refused with a code of its own
+*   ({@link HTTP_PROVIDER_ERROR_CODES.JSON_MEDIA_TYPE_INVALID}), symmetric with the
+*   SSE check. Parsing an HTML error page as if it were the provider's answer is how
+*   a proxy outage becomes a mysterious schema error further up.
+* - A body past `maxResponseBytes` is a transport failure, the same as on the SSE
+*   path, and is refused instead of truncated: half a JSON document is not data.
+* - A body that is not valid JSON is a protocol failure, never something to guess
+*   at.
+*
+* What `decode` receives is a response that already cleared every guard in
+* {@link withTransportSession} — 2xx, no redirect, attempt open, teardown owned —
+* plus a parsed body. What it owns is the schema.
+*
+* @module ai-agent-sdk/providers/transport/json
+*/
+/** Media types this pipeline accepts back from a provider. */
+const JSON_MEDIA_TYPES = Object.freeze(["application/json"]);
+/**
+* Send one request, read its JSON body under bound, and return `decode`'s value.
+*
+* The attempt closes as soon as the value is produced; nothing here stays open for
+* a consumer, because the whole response is already in memory by then.
+* @param input - request facts captured from one connection snapshot.
+* @param decode - turns a parsed body into the pipeline's own value.
+* @returns whatever `decode` returns.
+*/
+async function transportJson(input, decode) {
+	const decoded = [];
+	for await (const value of withTransportSession(input, async function* (session) {
+		const result = await decode(session, parseJsonBody(await readBoundedBody(session, input.displayName), input.displayName));
+		session.reportOutcome("success");
+		yield result;
+	})) {
+		decoded.push({ value });
+		break;
+	}
+	const first = decoded[0];
+	if (first === void 0) throw new ModelError(`${input.displayName} produced no JSON response`, MODEL_ERROR_CODES.MALFORMED_RESPONSE);
+	return first.value;
+}
+/** True when a `content-type` value names one of {@link JSON_MEDIA_TYPES}. */
+function isJsonMediaType(contentType) {
+	const mediaType = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+	if (mediaType === void 0) return false;
+	return JSON_MEDIA_TYPES.includes(mediaType);
+}
+/**
+* Read the whole body as text, refusing anything past the configured bounds.
+*
+* The declared `content-length` is checked first so an oversized response is
+* refused before a single byte of it is buffered; the streaming bound still applies
+* afterwards, because the header is a claim and not a guarantee.
+* @param session - the guarded response and its resolved limits.
+* @param displayName - provider name used in every message raised here.
+* @returns the exact body text.
+*/
+async function readBoundedBody(session, displayName) {
+	const response = session.response;
+	if (!isJsonMediaType(response.headers.get("content-type"))) throw new ModelError(`${displayName} response is not ${JSON_MEDIA_TYPES.join(" or ")}`, HTTP_PROVIDER_ERROR_CODES.JSON_MEDIA_TYPE_INVALID);
+	if (response.body === null) throw new ModelError(`${displayName} returned no response body`, MODEL_ERROR_CODES.MALFORMED_RESPONSE);
+	const maxResponseBytes = session.limits.maxResponseBytes;
+	const declaredLength = response.headers.get("content-length");
+	if (declaredLength !== null && /^\d+$/.test(declaredLength) && Number(declaredLength) > maxResponseBytes) throw new ModelError(`${displayName} response exceeds the ${maxResponseBytes}-byte limit`, MODEL_ERROR_CODES.TRANSPORT);
+	const reader = boundedResponseBody(response.body, maxResponseBytes, session.limits.maxResponseChunks, displayName, session.signal).getReader();
+	const decoder = new TextDecoder();
+	let text = "";
+	try {
+		while (true) {
+			const { done, value } = await raceWithSignal(reader.read(), session.signal);
+			if (done) break;
+			if (value === void 0) continue;
+			text += decoder.decode(value, { stream: true });
+		}
+		return text + decoder.decode();
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Parse a body, turning a parse failure into a protocol error rather than a guess. */
+function parseJsonBody(text, displayName) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new ModelError(`${displayName} response body is not valid JSON`, MODEL_ERROR_CODES.MALFORMED_RESPONSE, { cause: error });
+	}
+}
+
+//#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, JSON_MEDIA_TYPES, applyModelContextPolicy, captureTransportConnection, createHttpProvider, createModelContextPolicy, createRuntimeHttpProvider, defineWireProtocol, embeddingCatalogModelInfo, httpErrorCode, isJsonMediaType, observeCredentialOperation, observeModelCatalogOperation, parseErrorBody, parseSse, redactHeaders, requestIdFrom, resolveDialect, resolveTransportLimits, resolvedEmbeddingCatalogModelInfo, retryAfterMs, transportJson };
 //# sourceMappingURL=index.js.map