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

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { GenerateOptions, ModelAdapter, ModelError, ModelInfo, ModelInvocationContext, ModelModality, ModelReasoningInfo, NativeToolName, PreparedAdapterCall, ProviderInfo, ProviderRequestId, ResolvedModelInfo, ResolvedRetryPolicy, RetryPolicyConfig, StreamChunk, UsageCounters } from "@alvin0/ai-agent-sdk-core";
+import { GenerateOptions, ModelAdapter, ModelError, ModelFailure, ModelInfo, ModelInvocationContext, ModelModality, ModelReasoningInfo, NativeToolName, PreparedAdapterCall, ProviderInfo, ProviderRequestId, ResolvedModelInfo, ResolvedRetryPolicy, RetryPolicyConfig, StreamChunk, UsageCounters } from "@alvin0/ai-agent-sdk-core";
 import { CredentialInput, GenerateOptions as GenerateOptions$1, ModelInvocationContext as ModelInvocationContext$1, ResolvedModelInfo as ResolvedModelInfo$1, RetryPolicyConfig as RetryPolicyConfig$1, StreamChunk as StreamChunk$1, UsageCounters as UsageCounters$1 } from "@alvin0/ai-agent-sdk-core/provider";
+import { EmbeddingModelInfo, EmbeddingNormalization, EmbeddingPurposeHandling, ResolvedEmbeddingModelInfo } from "@alvin0/ai-agent-sdk-core/embedding";
 //#region src/stream/sse.d.ts
 /**
  * Decode an SSE byte stream into events.
@@ -63,12 +64,61 @@ type ProviderProtocolChunk = Exclude<StreamChunk, {
   readonly usage: UsageCounters;
 };
 //#endregion
-//#region src/base/transport.d.ts
+//#region src/transport/connection.d.ts
+/** The transport-shared half of a connection snapshot. */
+interface HttpTransportConnection {
+  /** Endpoint base; the pipeline's endpoint path is appended. */
+  readonly baseUrl: string;
+  /**
+   * Every header for the request, INCLUDING authorization.
+   *
+   * Resolved together with the endpoint so the credential travels with the URL it
+   * will be sent to. The transport adds attribution and `accept` on top.
+   */
+  readonly headers: Readonly<Record<string, string>>;
+  /** Auth-produced names that must be redacted regardless of spelling. */
+  readonly sensitiveHeaderNames?: readonly string[];
+  /** End-to-end request/stream timeout. */
+  readonly requestTimeoutMs?: number;
+  /** Maximum serialized outbound request bytes. */
+  readonly maxRequestBytes?: number;
+  /** Maximum cumulative successful response bytes. */
+  readonly maxResponseBytes?: number;
+  /** Maximum raw chunks accepted from a successful response. */
+  readonly maxResponseChunks?: number;
+  /** Maximum bytes read from a non-success response. */
+  readonly maxErrorBodyBytes?: number;
+  /** Maximum time granted to the optional request logger. */
+  readonly requestLoggerTimeoutMs?: number;
+  /** Permit cleartext HTTP explicitly, for trusted local development endpoints only. */
+  readonly allowInsecureHttp?: boolean;
+  /** Captured fetch implementation; omission uses the platform global. */
+  readonly fetch?: typeof globalThis.fetch;
+  /** Retry policy this route owns. */
+  readonly retryPolicy: ResolvedRetryPolicy;
+}
+/**
+ * Merge the transport's own header layer beneath the snapshot's auth layer, once.
+ *
+ * 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.
+ *
+ * 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.
+ */
+declare function captureTransportConnection<T extends HttpTransportConnection>(connection: T, transportHeaders: Readonly<Record<string, string>>): T;
+//#endregion
+//#region src/transport/http.d.ts
+/** Replace credential-bearing header values, by provenance and by name shape. */
 declare function redactHeaders(headers: Readonly<Record<string, string>>, sensitiveHeaderNames?: readonly string[]): Record<string, string>;
 //#endregion
-//#region src/base/http-adapter.d.ts
-/** Default idle bound: five minutes without a single byte is a hung stream. */
-declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
+//#region src/transport/limits.d.ts
 /** Default end-to-end bound once provider request construction begins. */
 declare const DEFAULT_REQUEST_TIMEOUT_MS: number;
 /** Default serialized request ceiling. */
@@ -81,6 +131,40 @@ declare const DEFAULT_MAX_RESPONSE_CHUNKS = 100000;
 declare const DEFAULT_MAX_ERROR_BODY_BYTES: number;
 /** Default diagnostic observer deadline; logging must never gate dispatch indefinitely. */
 declare const DEFAULT_REQUEST_LOGGER_TIMEOUT_MS = 5000;
+/**
+ * Every transport bound for one request, defaulted and validated exactly once.
+ *
+ * Resolved from the connection snapshot, so a configuration change between two
+ * reads cannot move a bound mid-request.
+ */
+interface ResolvedTransportLimits {
+  /** End-to-end request/stream timeout. */
+  readonly requestTimeoutMs: number;
+  /** Maximum serialized outbound request bytes. */
+  readonly maxRequestBytes: number;
+  /** Maximum cumulative successful response bytes. */
+  readonly maxResponseBytes: number;
+  /** Maximum raw chunks accepted from a successful response. */
+  readonly maxResponseChunks: number;
+  /** Maximum bytes read from a non-success response. */
+  readonly maxErrorBodyBytes: number;
+  /** Maximum time granted to the optional request logger. */
+  readonly requestLoggerTimeoutMs: number;
+}
+/**
+ * Apply defaults and reject nonsense bounds before any I/O happens.
+ *
+ * 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.
+ */
+declare function resolveTransportLimits(connection: HttpTransportConnection): ResolvedTransportLimits;
+//#endregion
+//#region src/base/http-adapter.d.ts
+/** Default idle bound: five minutes without a single byte is a hung stream. */
+declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
 /** One model a provider's configuration advertises. */
 interface ProviderCatalogModel {
   /** Wire model id, passed to the provider verbatim. */
@@ -91,8 +175,16 @@ interface ProviderCatalogModel {
   description?: string;
   /** Combined request/response capacity, when known. */
   contextWindow?: number;
+  /** Standard-price operating budget before a contextWindow override. */
+  defaultContextWindow?: number;
+  /** Known technical ceiling; overrides cannot exceed it. */
+  maxContextWindow?: number;
+  /** Input-token threshold for long-context pricing, when known. */
+  standardPriceInputTokens?: number;
   /** Per-request output cap for this model. */
   maxTokens?: number;
+  /** Default output budget, independently of the ceiling. Falls back to maxTokens. */
+  defaultMaxTokens?: number;
   /** Accepted request modalities; omission is treated as text-only. */
   inputModalities?: readonly ModelModality[];
   /** Modalities this model route may return. */
@@ -103,49 +195,26 @@ interface ProviderCatalogModel {
   reasoning?: ModelReasoningInfo;
 }
 /**
- * Everything needed to issue ONE request, captured as a single snapshot.
+ * Everything needed to issue ONE generation request, captured as a single snapshot.
  *
- * 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 call, makes that impossible.
+ * The transport half — endpoint, headers, bounds, retry policy — is
+ * {@link HttpTransportConnection} and is shared with every other pipeline in this
+ * package. What this interface adds is the part only generation has: the SSE
+ * decoding bounds and the advisory model catalog. The field set and the optionality
+ * of every field are unchanged from before the split, so existing provider
+ * configurations satisfy it exactly as they did.
+ *
+ * The catalog stays here deliberately. Embedding routes carry a catalog with
+ * different semantics, and folding the two into one shape is precisely the
+ * conflation this split avoids.
  */
-interface HttpConnection {
-  /** Endpoint base; the provider's {@link HttpModelAdapter.endpointPath} is appended. */
-  readonly baseUrl: string;
-  /**
-   * Every header for the request, INCLUDING authorization.
-   *
-   * Resolved in `connect()` so the credential travels with the endpoint it will
-   * be sent to. The base pipeline adds attribution and `accept` on top.
-   */
-  readonly headers: Readonly<Record<string, string>>;
-  /** Auth-produced names that must be redacted regardless of spelling. */
-  readonly sensitiveHeaderNames?: readonly string[];
+interface HttpConnection extends HttpTransportConnection {
   /** Maximum idle interval while a read is outstanding. */
   readonly streamIdleTimeoutMs: number;
-  /** End-to-end request/stream timeout. */
-  readonly requestTimeoutMs?: number;
-  /** Maximum serialized outbound request bytes. */
-  readonly maxRequestBytes?: number;
-  /** Maximum cumulative successful response bytes. */
-  readonly maxResponseBytes?: number;
-  /** Maximum raw chunks accepted from a successful response. */
-  readonly maxResponseChunks?: number;
   /** Maximum decoded SSE events accepted from one response. */
   readonly maxSseEvents?: number;
   /** Maximum characters accepted in one decoded SSE event. */
   readonly maxSseEventChars?: number;
-  /** Maximum bytes read from a non-success response. */
-  readonly maxErrorBodyBytes?: number;
-  /** Maximum time granted to the optional request logger. */
-  readonly requestLoggerTimeoutMs?: number;
-  /** Permit cleartext HTTP explicitly, for trusted local development endpoints only. */
-  readonly allowInsecureHttp?: boolean;
-  /** Captured fetch implementation; omission uses the platform global. */
-  readonly fetch?: typeof globalThis.fetch;
-  /** Retry policy this route owns. */
-  readonly retryPolicy: ResolvedRetryPolicy;
   /** Advisory catalog; requests are never restricted to it. */
   readonly models: readonly ProviderCatalogModel[];
   /** Output cap applied when neither the caller nor the model entry names one. */
@@ -253,15 +322,31 @@ declare abstract class HttpModelAdapter extends ModelAdapter {
   /** Capture legacy subclass transport/auth layers once; configured adapters already return all five. */
   private captureConnection;
   /**
-   * 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.
    */
   private run;
+  /**
+   * 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.
+   */
+  private decodeSse;
   private prepareWireBody;
-  /** Turn a non-2xx response into a fully populated {@link ModelError}. */
-  private httpFailure;
 }
 //#endregion
-//#region src/base/http-errors.d.ts
+//#region src/transport/errors.d.ts
 /**
  * Map an HTTP status plus whatever the provider said into a stable code.
  *
@@ -310,6 +395,22 @@ interface ParsedErrorBody {
  */
 declare function parseErrorBody(raw: string): ParsedErrorBody;
 //#endregion
+//#region src/base/context-policy.d.ts
+/** Context facts only: never advertises models or guesses their capabilities. */
+interface ModelContextPolicy {
+  readonly defaultContextWindow: number;
+  readonly maxContextWindow?: number;
+  readonly standardPriceInputTokens?: number;
+}
+interface ModelContextPolicyOptions {
+  readonly baseUrl?: string;
+  readonly models?: readonly ProviderCatalogModel[];
+  readonly defaultContextWindow?: number;
+}
+declare function applyModelContextPolicy(info: ResolvedModelInfo, policy: ModelContextPolicy | undefined, configured?: ProviderCatalogModel, providerOverride?: number): ResolvedModelInfo;
+/** Capture configuration so later caller mutations cannot change model resolution. */
+declare function createModelContextPolicy(policies: Readonly<Record<string, ModelContextPolicy>>, models: readonly ProviderCatalogModel[] | undefined, providerOverride?: number): (info: ResolvedModelInfo) => ResolvedModelInfo;
+//#endregion
 //#region src/common/config.d.ts
 /** Runtime wire-protocol contract version supported by this package. */
 declare const HTTP_PROTOCOL_API_VERSION: 1;
@@ -322,6 +423,7 @@ declare const HTTP_PROVIDER_ERROR_CODES: Readonly<{
   readonly WIRE_BODY_INVALID: 'HTTP_WIRE_BODY_INVALID';
   readonly WIRE_BODY_TOO_LARGE: 'HTTP_WIRE_BODY_TOO_LARGE';
   readonly STREAM_MEDIA_TYPE_INVALID: 'HTTP_STREAM_MEDIA_TYPE_INVALID';
+  readonly JSON_MEDIA_TYPE_INVALID: 'HTTP_JSON_MEDIA_TYPE_INVALID';
   readonly SSE_LIMIT_EXCEEDED: 'HTTP_SSE_LIMIT_EXCEEDED';
   readonly REDIRECT_REJECTED: 'HTTP_REDIRECT_REJECTED';
 }>;
@@ -637,5 +739,206 @@ declare function createRuntimeHttpProvider<Dialect extends object>(options: Runt
 declare function observeCredentialOperation<T>(context: ModelInvocationContext | undefined, provider: string, operation: 'resolve' | 'refresh' | 'login', task: () => Promise<T>): Promise<T>;
 declare function observeModelCatalogOperation<T>(context: ModelInvocationContext | undefined, provider: string, origin: string, task: () => Promise<T>): Promise<T>;
 //#endregion
-export { AnyWireProtocol, AuthScheme, CredentialSource, 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, type HttpAuthResolveOptions, type HttpConnection, HttpModelAdapter, HttpProviderOptions, ModelDiscoveryContext, type ParsedErrorBody, type ProtocolRequest, type ProtocolSseEvent, type ProtocolStreamChunk, type ProviderCatalogModel, type ProviderRequest, type ProviderRequestLogRecord, type ProviderRequestLogger, type RuntimeAuthScheme, type RuntimeCredentialSource, type RuntimeHttpProviderOptions, type RuntimeModelDiscoveryContext, type RuntimeWireProtocol, SseEvent, WireProtocol, WireProtocolChunk, type WireProtocolDefinition, createHttpProvider, createRuntimeHttpProvider, defineWireProtocol, httpErrorCode, observeCredentialOperation, observeModelCatalogOperation, parseErrorBody, parseSse, redactHeaders, requestIdFrom, resolveDialect, retryAfterMs };
+//#region src/transport/embedding-connection.d.ts
+/**
+ * One embedding model an HTTP route declares.
+ *
+ * Every capability field is optional but one: {@link compatibilityIdentity}. A
+ * vector is only meaningful next to another vector from the same space, and no
+ * amount of matching dimension counts establishes that. Requiring the claim in
+ * the type means a self-hosted "OpenAI-compatible" endpoint is a tested profile
+ * someone declared, not an assumption drawn from the endpoint having an
+ * `/embeddings` path (Requirement 15.3).
+ */
+interface EmbeddingCatalogModel {
+  /** Wire model id, passed to the provider verbatim. */
+  readonly id: string;
+  /** Selector label; defaults to {@link id}. */
+  readonly name?: string;
+  /** Optional detail distinguishing similar variants. */
+  readonly description?: string;
+  /** Selectable vector widths this route accepts. */
+  readonly dimensions?: readonly number[];
+  /** Width used when the caller requests none. */
+  readonly defaultDimensions?: number;
+  /** Per-input token ceiling. Only a declared value may reject an input. */
+  readonly maxInputTokens?: number;
+  /** Items accepted in one physical batch. */
+  readonly maxBatchItems?: number;
+  /** Estimated tokens accepted in one physical batch. */
+  readonly maxBatchTokens?: number;
+  /** Payload bytes accepted in one physical batch. */
+  readonly maxBatchBytes?: number;
+  /**
+   * How this route expresses purpose on the wire.
+   *
+   * `'unsupported'` is the positive negative claim — the route states it has no
+   * mechanism, which is what OpenAI's embeddings API is — and it is distinct
+   * from omitting the field, which claims nothing. Either way the adapter sends
+   * the text verbatim and never invents an undocumented prefix.
+   */
+  readonly purposeHandling?: EmbeddingPurposeHandling | 'unsupported';
+  /** Whether vectors arrive normalized. Never inferred from dimension count. */
+  readonly normalization?: EmbeddingNormalization;
+  /**
+   * The route's explicit declaration about the embedding space.
+   *
+   * Required, including for a self-hosted endpoint. Models sharing a declared
+   * space share this string; a new model generation gets a new one even when the
+   * vector width is unchanged.
+   */
+  readonly compatibilityIdentity: string;
+}
+/**
+ * Everything needed to issue ONE embedding request, captured as a single snapshot.
+ *
+ * The transport half — endpoint, headers, bounds, cleartext opt-in, retry
+ * policy — is {@link HttpTransportConnection} and is shared with the generation
+ * pipeline verbatim. Both `OpenAI_Embedding_Adapter` and
+ * `Gemini_Embedding_Adapter` are configured through this one shape.
+ */
+interface EmbeddingHttpConnection extends HttpTransportConnection {
+  /** Advisory catalog; requests are never restricted to it. */
+  readonly models: readonly EmbeddingCatalogModel[];
+}
+/**
+ * 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.
+ */
+declare function embeddingCatalogModelInfo(provider: string, model: EmbeddingCatalogModel): EmbeddingModelInfo;
+/**
+ * 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.
+ */
+declare function resolvedEmbeddingCatalogModelInfo(provider: string, modelId: string, models: readonly EmbeddingCatalogModel[]): ResolvedEmbeddingModelInfo;
+//#endregion
+//#region src/transport/session.d.ts
+/** One serialized request body, measured before anything is sent. */
+interface PreparedWireBody {
+  /** The value handed to the diagnostic observer; never re-serialized. */
+  readonly value: unknown;
+  /** Exact bytes sent on the wire. */
+  readonly encoded: string;
+  /** UTF-8 length of {@link encoded}. */
+  readonly bytes: number;
+}
+/**
+ * How the transport obtains the body.
+ *
+ * A thunk exists because the pipeline that owns serialization also owns caching it
+ * across repeated `stream()` calls on one prepared call, and because building the
+ * body may itself do work that must observe the fused signal — which does not exist
+ * until the transport creates it.
+ */
+type WireBodySource = PreparedWireBody | ((signal: AbortSignal) => PreparedWireBody | Promise<PreparedWireBody>);
+/**
+ * One exact wire request, observed immediately before dispatch.
+ *
+ * Structurally identical to the generation pipeline's record, and deliberately
+ * declared here so the transport does not depend on a pipeline for its own shape.
+ */
+interface WireRequestRecord {
+  readonly schemaVersion: 1;
+  readonly type: 'provider-request';
+  readonly id: string;
+  readonly timestamp: string;
+  readonly provider: string;
+  readonly model: string;
+  readonly method: 'POST';
+  readonly url: string;
+  /** Credentials and cookies already replaced by `[REDACTED]`. */
+  readonly headers: Readonly<Record<string, string>>;
+  /** The exact serialized value. This may contain prompts and tool output. */
+  readonly body: unknown;
+  readonly bodyBytes: number;
+}
+/** Everything the shared chain needs to issue ONE request. */
+interface HttpTransportRequestInput {
+  /** The snapshot this request is bound to; read once, never re-read mid-request. */
+  readonly connection: HttpTransportConnection;
+  /** Provider display name used in every message this chain raises. */
+  readonly displayName: string;
+  /** Route being served. */
+  readonly provider: string;
+  /** Wire model id. */
+  readonly model: string;
+  /** Path appended to {@link HttpTransportConnection.baseUrl}. */
+  readonly path: string;
+  /**
+   * Media type this pipeline requires back.
+   *
+   * The transport does not enforce it — the `accept` header travels on the
+   * connection snapshot and the check belongs to whoever decodes — but it is carried
+   * on the session so `decode` states its expectation in one place.
+   */
+  readonly accept: string;
+  readonly body: WireBodySource;
+  /** The caller's cancellation, fused with the deadline and our teardown. */
+  readonly signal?: AbortSignal;
+  readonly context?: ModelInvocationContext;
+  /** Override status-to-code mapping for a provider with codes of its own. */
+  readonly errorCode?: (status: number, detail: string) => string;
+  /** Best-effort diagnostic observer; never a dispatch veto. */
+  readonly observeRequest?: (record: WireRequestRecord) => Promise<void> | void;
+}
+/** Outcome vocabulary a pipeline may report for the attempt ledger. */
+type TransportAttemptStatus = 'success' | 'error' | 'aborted' | 'unknown';
+/** A response that already cleared every transport guard, plus its ledger hooks. */
+interface HttpTransportSession {
+  /** The response; its body is still unread and is owned by the transport. */
+  readonly response: Response;
+  readonly url: string;
+  readonly origin: string;
+  /** Fused signal: caller + request deadline + transport teardown. */
+  readonly signal: AbortSignal;
+  /** Provider correlation id, when the response carried one. */
+  readonly providerRequestId?: ProviderRequestId;
+  /** Media type the pipeline asked for; see {@link HttpTransportRequestInput.accept}. */
+  readonly accept: string;
+  readonly limits: ResolvedTransportLimits;
+  /**
+   * Record a usage report as attempt evidence.
+   *
+   * Evidence only: whether a report is complete enough to leave the SDK as
+   * `TokenUsage` is a pipeline decision, and this hook does not make it.
+   */
+  readonly attemptId?: string;
+  reportUsage(usage: UsageCounters, final?: boolean): void;
+  /** Record the terminal outcome the decoded stream reported. */
+  reportOutcome(status: TransportAttemptStatus, failure?: ModelFailure): void;
+}
+//#endregion
+//#region src/transport/json.d.ts
+/** Media types this pipeline accepts back from a provider. */
+declare const JSON_MEDIA_TYPES: readonly ["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.
+ */
+declare function transportJson<T>(input: HttpTransportRequestInput, decode: (session: HttpTransportSession, body: unknown) => T | Promise<T>): Promise<T>;
+/** True when a `content-type` value names one of {@link JSON_MEDIA_TYPES}. */
+declare function isJsonMediaType(contentType: string | null): boolean;
+//#endregion
+export { AnyWireProtocol, AuthScheme, CredentialSource, 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, EmbeddingCatalogModel, EmbeddingHttpConnection, HTTP_PROTOCOL_API_VERSION, HTTP_PROVIDER_ERROR_CODES, type HttpAuthResolveOptions, type HttpConnection, HttpModelAdapter, HttpProviderOptions, type HttpTransportConnection, type HttpTransportRequestInput, type HttpTransportSession, JSON_MEDIA_TYPES, ModelContextPolicy, ModelContextPolicyOptions, ModelDiscoveryContext, type ParsedErrorBody, type PreparedWireBody, type ProtocolRequest, type ProtocolSseEvent, type ProtocolStreamChunk, type ProviderCatalogModel, type ProviderRequest, type ProviderRequestLogRecord, type ProviderRequestLogger, type ResolvedTransportLimits, type RuntimeAuthScheme, type RuntimeCredentialSource, type RuntimeHttpProviderOptions, type RuntimeModelDiscoveryContext, type RuntimeWireProtocol, SseEvent, type WireBodySource, WireProtocol, WireProtocolChunk, type WireProtocolDefinition, applyModelContextPolicy, captureTransportConnection, createHttpProvider, createModelContextPolicy, createRuntimeHttpProvider, defineWireProtocol, embeddingCatalogModelInfo, httpErrorCode, isJsonMediaType, observeCredentialOperation, observeModelCatalogOperation, parseErrorBody, parseSse, redactHeaders, requestIdFrom, resolveDialect, resolveTransportLimits, resolvedEmbeddingCatalogModelInfo, retryAfterMs, transportJson };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/stream/sse.ts","../src/stream/types.ts","../src/base/transport.ts","../src/base/http-adapter.ts","../src/base/http-errors.ts","../src/common/config.ts","../src/protocol/runtime-types.ts","../src/protocol/definition.ts","../src/protocol/protocol.ts","../src/configurable/http-provider.ts","../src/configurable/runtime-types.ts","../src/configurable/runtime-provider.ts","../src/observation/operations.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/stream/sse.ts","../src/stream/types.ts","../src/transport/connection.ts","../src/transport/http.ts","../src/transport/limits.ts","../src/base/http-adapter.ts","../src/transport/errors.ts","../src/base/context-policy.ts","../src/common/config.ts","../src/protocol/runtime-types.ts","../src/protocol/definition.ts","../src/protocol/protocol.ts","../src/configurable/http-provider.ts","../src/configurable/runtime-types.ts","../src/configurable/runtime-provider.ts","../src/observation/operations.ts","../src/transport/embedding-connection.ts","../src/transport/session.ts","../src/transport/json.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;;;;;;;EAQf;;EAEA;;;;;;;;;;;;;;iBAeqB,SACrB,QAAQ,eAAe,aACvB,yBACA,6BACC,eAAe;;;;KC7DN,wBACR,QAAQ;WAAwB;;WACrB;WAAwB,OAAO;;;;;UCiB7B;;WAEN;;;;;;;WAOA,SAAS,SAAS;;WAElB;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA,eAAe,WAAW;;WAE1B,aAAa;;;;;;;;;;;;;;;;;iBAkBR,2BAA2B,UAAU,yBACnD,YAAY,GACZ,kBAAkB,SAAS,0BAC1B;;;;iBCyJa,cACd,SAAS,SAAS,yBAClB,2CACC;;;;cCrNU;;cAEA;;cAEA;;cAEA;;cAEA;;cAEA;;;;;;;UAsBI;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;;iBAYK,uBACd,YAAY,0BACX;;;;cCEU;;UAGI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,2BAA2B;;EAE3B,4BAA4B;;EAE5B,uBAAuB;;EAEvB,YAAY;;;;;;;;;;;;;;;;UAiBG,uBAAuB;;WAE7B;;WAEA;;WAEA;;WAEA,iBAAiB;;WAEjB;;WAEA;;;UAIM;;WAEN,SAAS;;WAET,OAAO;;WAEP,YAAY;;WAEZ;;;;;;UAOM;;WAEN;WACA;;WAEA;WACA;WACA;WACA;WACA;WACA;;WAEA,SAAS,SAAS;;WAElB;WACA;;;;;;KAOC,yBACV,QAAQ,6BACL;;uBA6CiB,yBAAyB;;8BAEjB;;;;;;;;;qBAUT,QACjB,kBACA,SAAS,aACT,UAAU,yBACT,QAAQ;;qBAGQ,aAAa,SAAS;;qBAGtB,UAAU,SAAS,kBAAkB;;;;;;;;qBASrC,UACjB,QAAQ,cAAc,WACtB,SAAS,kBACR,eAAe;;;;;YAMR,eAAe;;;;;;;;YAcf,eAAe,SAAS,2BAA2B;;;;;YAMnD,kBAAkB,gBAAgB;EAInC,aAAa,mBAAmB;EAI1B,WAAW,kBAAkB,SAAS,cAAc,iBAAiB;EAKrE,aACb,kBACA,eACA,SAAS,cACR,QAAQ;EAKI,YACb,kBACA,eACA,SAAS,aACT,UAAU,yBACT,QAAQ;;;;;;;EAyBX,OAAO,SAAS,iBAAiB,UAAU,yBAAyB,cAAc;;UAKlE;;YAaN,aACR,YAAY,gBACZ,kBACA,gBACC;;YAQO,cACR,MAAM,mBACN,aAAa,iBACZ;;UAKK;;;;;;;;;UAYQ;;;;;;;;;;;;;UAsEA;UA8EF;;;;;;;;;;;;;;iBC/eA,cAAc,gBAAgB;;;;;;;;;;iBA4B9B,aAAa;;;;;;;;;iBA2Bb,cAAc,SAAS,UAAU;;UAShC;;EAEf;;EAEA;;;;;;;;;;;iBAmBc,eAAe,cAAc;;;;UCvH5B;WACN;WACA;WACA;;UAGM;WACN;WACA,kBAAkB;WAClB;;iBAGK,wBACd,MAAM,mBACN,QAAQ,gCACR,aAAa,sBACb,4BACC;;iBA6Ba,yBACd,UAAU,SAAS,eAAe,sBAClC,iBAAiB,oCACjB,6BACE,MAAM,sBAAsB;;;;cCrDnB;;cAGA,2BAAyB;WACV;WACV;WACC;WACC;WACC;WACE;WACM;WACF;WACL;WACD;;;;UCJJ;WACN;WACA;;KAGC,sBACR,QAAQ;WAAwB;;WACrB;WAAwB,OAAO;;UAE7B;WACN,SAAS;WACT,OAAO;WACP,YAAY;WACZ;;;UAIM,oBAAoB;WAC1B;WACA,mBAAmB;WACnB;WACA,gBAAgB;WAChB,eAAe,SAAS,iBAAiB,SAAS;WAClD,mBAAmB,SAAS,YAAY,SAAS;WACjD,YAAY,SAAS,iBAAiB,SAAS,YAAY,SAAS;WACpE,YACP,QAAQ,cAAc,mBACtB,SAAS,iBACT,wBACG,eAAe;;KAGV,uBAAuB,0BAA0B,KAC3D,oBAAoB;UAIL;WACN;WACA,SAAS;WACT,QAAQ;WACR,UAAU;;;;;;;;iBC9BL,mBAAmB,wBACjC,YAAY,uBAAuB,WAClC,oBAAoB;;;;KCQX,oBAAoB;;;;;;;;;UAUf,aAAa;;WAEnB;;;;;;;WAQA,gBAAgB;;EAGzB,aAAa,SAAS,iBAAiB,SAAS;;;;;;;;EAShD,iBAAiB,SAAS,UAAU;;EAGpC,UAAU,SAAS,iBAAiB,SAAS,oBAAoB;;;;;;;EAQjE,UACE,QAAQ,cAAc,WACtB,SAAS,iBACT,sBACC,eAAe;;;KAIR,kBAAkB;;;;;;;;;;iBAWd,eAAe,wBAC7B,UAAU,aAAa,UACvB,WAAW,QAAQ,uBAClB;;;;KCxBS,8BACV,SAAS,aACT,UAAU,oCACE;;;;;;;;KASF;;;EAEN;;;;EAEA;EAAgB,OAAO;EAAkB;;;;EAEzC;EAAgB;EAAc,OAAO;EAAkB;;;;EAGzD;EACA,UACE,SAAS,aACT,UAAU,wBACV,sBACG,yBAAyB,QAAQ;;;UAQzB;;WAEN;;WAEA,SAAS,SAAS;WAClB,SAAS;;WAET;;WAEA,UAAU;;;UAIJ,oBAAoB;;EAEnC;;EAEA,UAAU,aAAa;;EAEvB;;EAEA;;EAEA,eAAe,WAAW;;EAE1B,MAAM;;;;;;EAMN,UAAU,QAAQ;;EAElB,UAAU,gCAAgC;;;;;;;;EAQ1C,kBAAkB;;;;;;;;EAQlB,kBAAkB,SAAS,0BAA0B,iBAAiB;;EAEtE;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;EAQA,iBAAiB,MAAM,mBAAmB,SAAS,YAAY;;EAE/D;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,cAAc;;;;;;;EAOd,aAAa,gBAAgB;;EAE7B,cAAc;;;;;;EAMd,gBAAgB;;;;;;;iBAoYF,mBAAmB,wBACjC,SAAS,oBAAoB,WAC5B;;;KC9kBS,0BAA0B;KAE1B;WACG;;WACA;WAAyB,OAAO;WAAkC;;WAEpE;WACA;WACA,OAAO;WACP;;WAGA;WACA,UACP,SAAS,2BACN,SAAS,0BAA0B,QAAQ,SAAS;;UAG5C;WACN;WACA,SAAS;WACT,SAAS,SAAS;WAClB,QAAQ;WACR,UAAU;;UAGJ,2BAA2B;WACjC;WACA,UAAU,oBAAoB;WAC9B,kBAAkB;WAClB;WACA,MAAM;WACN,kBAAkB;WAClB,UAAU,QAAQ;WAClB,eAAe,WAAW;WAC1B,UAAU,SAAS,iCAAiC,SAAS;WAC7D,kBACP,SAAS,iCACN,iBAAiB;WACb;WACA;WACA;WACA;WACA;WACA,iBAAiB,MAAM,qBAAmB,SAAS,YAAY;WAC/D;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA,cAAc;WACd,aAAa,gBAAgB;WAC7B,cAAc,SAAS;WACvB,gBAAgB;;;;;iBCxBX,0BAA0B,wBACxC,SAAS,2BAA2B,WACnC;;;iBCqEa,2BAA2B,GACzC,SAAS,oCACT,kBACA,4CACA,YAAY,QAAQ,KACnB,QAAQ;iBASK,6BAA6B,GAC3C,SAAS,oCACT,kBACA,gBACA,YAAY,QAAQ,KACnB,QAAQ;;;;;;;;;;;;;UCtFM;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;WASA,kBAAkB;;WAElB,gBAAgB;;;;;;;;WAQhB;;;;;;;;;;UAWM,gCAAgC;;WAEtC,iBAAiB;;;;;;;;;;;;;;iBAkCZ,0BACd,kBACA,OAAO,wBACN;;;;;;;;;;;;;iBAgCa,kCACd,kBACA,iBACA,iBAAiB,0BAChB;;;;UCrHc;;WAEN;;WAEA;;WAEA;;;;;;;;;;KAWC,iBACR,qBACE,QAAQ,gBAAgB,mBAAmB,QAAQ;;;;;;;UAQxC;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA,SAAS,SAAS;;WAElB;WACA;;;UAIM;;WAEN,YAAY;;WAEZ;;WAEA;;WAEA;;WAEA;;;;;;;;WAQA;WACA,MAAM;;WAEN,SAAS;WACT,UAAU;;WAEV,aAAa,gBAAgB;;WAE7B,kBAAkB,QAAQ,sBAAsB;;;KAI/C;;UAGK;;WAEN,UAAU;WACV;WACA;;WAEA,QAAQ;;WAER,oBAAoB;;WAEpB;WACA,QAAQ;;;;;;;WAOR;EACT,YAAY,OAAO,eAAe;;EAElC,cAAc,QAAQ,wBAAwB,UAAU;;;;;cCrH7C;;;;;;;;;;iBAWS,cAAc,GAClC,OAAO,2BACP,SAAS,SAAS,sBAAsB,kBAAkB,IAAI,QAAQ,KACrE,QAAQ;;iBA4BK,gBAAgB"}