@superdurable/connectors-sdk 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # Connector TypeScript SDK
 
-`@superdurable/connectors-sdk` is the provider-neutral TypeScript SDK for Dex connectors. It provides stable value contracts, typed Query and Mutation operations, Dex Step factories, credential refresh, OAuth token exchanges, HTTP safety helpers, project configuration loading, scripted mocks, and single-dispatch marker decisions. The package is at version `0.2.0`, requires Node 22 or 24, and uses `@superdurable/dex` 1.28.0 or newer. It is ESM-only, matching Dex: use `import`; direct `require()` fails with `ERR_PACKAGE_PATH_NOT_EXPORTED`.
+`@superdurable/connectors-sdk` is the provider-neutral TypeScript SDK for Dex connectors. It provides stable value contracts, typed Query and Mutation operations, Dex Step factories, credential refresh, OAuth token exchanges, HTTP safety helpers, project configuration loading, scripted mocks, and single-dispatch marker decisions. The package is at version `0.3.0`, requires Node 22 or 24, and uses `@superdurable/dex` 1.28.0 or newer. It is ESM-only, matching Dex: use `import`; direct `require()` fails with `ERR_PACKAGE_PATH_NOT_EXPORTED`.
 
 Install dependencies and verify the package from this directory:
 
@@ -119,6 +119,7 @@ if (result.kind !== 'branch' || retryPolicy.totalDurationMs !== 3600000 || crede
 
 The [complete runnable HTTP example](examples/providerhttp.mjs) sends one bounded request to a local server. `sendProviderRequest` resolves every address before connecting, pins the chosen address for IP literals and hostnames, and returns redirects without following them. `ProviderTransportError.isProvablyNotSent` is true for DNS, TCP connect, or TLS handshake failures before a usable connection could send HTTP bytes. Failures after connection or request writing have an unknown dispatch outcome, matching the Go connectors' DNS, connect, TLS, and obtained-connection trace.
 `BodyTooLargeError` preserves the response `status` and `headers`, so a caller can classify a 429 or 503 and its `Retry-After` even when the response body exceeds its limit.
+`ProviderRequest.onBodyLimit` defaults to `destroy`, closing an oversized response immediately. Set it to `drain` for provider calls that continue or bill work after a client disconnect: the SDK releases buffered bytes, delivers callback bytes only through the limit, reads to EOF, then rejects with `BodyTooLargeError`. Drain requires at least one positive `timeoutMs`, positive `stallTimeoutMs`, or `signal`; otherwise `sendProviderRequest` throws `TypeError`. These bounds remain active while draining. For non-2xx responses, an explicit `maxErrorResponseBytes` takes precedence and truncates the body immediately instead of draining. Once drain begins, a later read failure still rejects with `BodyTooLargeError`, including when `ignoreErrorBodyReadFailure` is set. The runnable example exercises `drain` with a local server.
 
 ```js
 import { createServer } from 'node:http';
@@ -230,7 +231,7 @@ mutation.assertNoFailures();
 
 ## OAuth token refresh
 
-The [runnable OAuth exchange example](examples/oauthtoken.mjs) shows a provider-neutral refresh-token grant. The injected `fetch` returns a local fixture; a connector normally uses the provider's fixed HTTPS token endpoint. `TokenEndpoint` also supports client-credentials and JWT-bearer grants, optional Basic authentication, declared response fields, bounded responses, and terminal OAuth error-code classification. The [manifest refresh example](examples/manifest_refresh.mjs) uses `ManifestCredentialRefreshDriver` with a generated authorization declaration and field map to exchange refresh-token, client-credentials, or JWT-bearer grants, preserve rotated material, check scopes, and replace only mapped fields. Constructor options also accept startup-pinned `settings`, a caller-owned `fetch`, and an injectable `now` clock. Credentials for a connector with several authorization methods must carry `authMethodId`. The manifest must declare `refresh.acceptsMissingTokenType` for providers that omit `token_type` and grant `acceptedTokenTypes` for providers such as Slack that return `bot` or `user`; schema and codegen support for these declarations is pending before connector migration. Only declared terminal OAuth errors below HTTP 500 require reauthorization; transport, server, and other token errors remain retryable.
+The [runnable OAuth exchange example](examples/oauthtoken.mjs) shows a provider-neutral refresh-token grant. The injected `fetch` returns a local fixture; a connector normally uses the provider's fixed HTTPS token endpoint. `TokenEndpoint` also supports client-credentials and JWT-bearer grants, optional Basic authentication, declared response fields, bounded responses, and terminal OAuth error-code classification. The [manifest refresh example](examples/manifest_refresh.mjs) uses `ManifestCredentialRefreshDriver` with a generated authorization declaration and field map to exchange refresh-token, client-credentials, or JWT-bearer grants, preserve rotated material, check scopes, and replace only mapped fields. Constructor options also accept startup-pinned `settings`, a caller-owned `fetch`, and an injectable `now` clock. Credentials for a connector with several authorization methods use `authMethodId`; an empty value selects `defaultMethod`. Refresh validation uses `requiredScopes` when declared, and a grant can override `exactScopes` or `acceptsMissingTokenType`. `refresh.scopeSeparators` selects `whitespace` (the default) or `whitespaceAndComma` for both exact and all-scope checks. A blank client secret requires reauthorization unless `refresh.allowsPublicClient` is true. A response lacking `expires_in` is retryable unless the manifest declares `missingExpiry`. Only declared terminal OAuth errors below HTTP 500 require reauthorization; transport, server, and other token errors remain retryable.
 
 An access token with no stored expiry remains usable; the current project provider requires authoritative expiry before forcing refresh after a provider rejection. A response without `expires_in` uses the manifest's `missingExpiry` lifetime or returns an expired result for `keep`. The current project provider rejects that result without changing stored material. Refreshing multiple grants follows the Go driver's current single-expiry behavior: active grants rotate together and the earliest expiry wins. A process failure between provider response and persistence, or failure of a later grant after an earlier rotation, can lose a one-use refresh token.
 
@@ -280,6 +281,12 @@ await fence.recordProviderId(result.providerId);
 
 ## Release notes
 
+### 0.3.0
+
+Adds declaration-driven required and exact scope checks, per-grant token-type rules, Go-compatible duration validation, and default-method selection for manifest refresh drivers. Scope parsing now follows `scopeSeparators`: whitespace by default, or spaces and commas when declared. A blank client secret now requires reauthorization unless public-client refresh is declared. A missing `expires_in` is retryable unless the manifest declares `missingExpiry`. These changes alter the published 0.2.0 refresh driver's behavior.
+
+Public HTTPS address checks now refuse the IPv4 broadcast address, matching Go's global-unicast rule. Adds opt-in draining of oversized Provider HTTP responses with bounded cancellation and byte-exact chunk callbacks.
+
 ### 0.2.0
 
 Adds manifest-driven refresh for OAuth, client-credentials, and JWT bearer grants, including rotated refresh tokens, declared scope and token-type checks, and retryable token endpoint failures. Connector migration requires schema and codegen support for the new token-type declarations.

package/dist/{chunk-BG65RPGH.js → chunk-UWB627CI.js}

@@ -43,7 +43,7 @@ function isLinkLocalIPAddressLiteral(hostname) {
 }
 function isAlwaysRefusedIPAddressLiteral(hostname) {
   const address = unbracketHostname(hostname);
-  return address === "0.0.0.0" || address === "::" || address.toLowerCase() === "fd00:ec2::254" || contains(linkLocal, address) || contains(multicast, address);
+  return address === "0.0.0.0" || address === "255.255.255.255" || address === "::" || address.toLowerCase() === "fd00:ec2::254" || contains(linkLocal, address) || contains(multicast, address);
 }
 function isAllowedProviderIPAddress(address, protocol, policy) {
   if (isIP(unbracketHostname(address)) === 0 || isAlwaysRefusedIPAddressLiteral(address)) return false;
@@ -161,6 +161,8 @@ function readErrorTokens(body, pointers) {
 async function sendProviderRequest(request) {
   if (!Number.isSafeInteger(request.maxResponseBytes) || request.maxResponseBytes < 0) throw new RangeError("response body limit must be a non-negative integer");
   if (request.maxErrorResponseBytes !== void 0 && (!Number.isSafeInteger(request.maxErrorResponseBytes) || request.maxErrorResponseBytes < 0)) throw new RangeError("error body limit must be a non-negative integer");
+  if (request.onBodyLimit !== void 0 && request.onBodyLimit !== "destroy" && request.onBodyLimit !== "drain") throw new TypeError("response body limit action is invalid");
+  if (request.onBodyLimit === "drain" && !(request.timeoutMs && request.timeoutMs > 0) && !(request.stallTimeoutMs && request.stallTimeoutMs > 0) && !request.signal) throw new TypeError("draining requires a timeout or abort signal");
   if (request.addressPolicy !== "publicHTTPS" && request.addressPolicy !== "privateNetworkHTTP" && request.addressPolicy !== "unrestricted") throw new AddressRefusal("address policy is invalid");
   let parsed;
   try {
@@ -195,13 +197,16 @@ async function sendProviderRequest(request) {
   return new Promise((resolve, reject) => {
     let hasConnected = false;
     let hasWrittenRequest = false;
+    let hasReceivedResponse = false;
     let clientRequest;
     let responseStallTimer;
     try {
       clientRequest = (parsed.protocol === "https:" ? https : http).request(parsed, options, (response) => {
+        hasReceivedResponse = true;
         if (responseStallTimer) clearTimeout(responseStallTimer);
         const chunks = [];
         let size = 0;
+        let isBodyTooLarge = false;
         let stallTimer;
         const observeProgress = () => {
           if (stallTimer) clearTimeout(stallTimer);
@@ -212,6 +217,7 @@ async function sendProviderRequest(request) {
           try {
             for await (const chunk of response) {
               observeProgress();
+              if (isBodyTooLarge) continue;
               const isSuccess = (response.statusCode ?? 0) >= 200 && (response.statusCode ?? 0) <= 299;
               const limit = isSuccess ? request.maxResponseBytes : request.maxErrorResponseBytes ?? request.maxResponseBytes;
               if (!isSuccess && request.maxErrorResponseBytes !== void 0 && size + chunk.length > limit) {
@@ -220,6 +226,13 @@ async function sendProviderRequest(request) {
                 resolve({ status: response.statusCode ?? 0, headers: response.headers, body: Buffer.concat(chunks) });
                 return;
               }
+              if (request.onBodyLimit === "drain" && size + chunk.length > limit) {
+                const remainingBytes = limit - size;
+                isBodyTooLarge = true;
+                chunks.length = 0;
+                if (remainingBytes > 0) request.onResponseChunk?.(chunk.subarray(0, remainingBytes), response.statusCode ?? 0, response.headers);
+                continue;
+              }
               const shouldContinue = request.onResponseChunk?.(chunk, response.statusCode ?? 0, response.headers);
               if (shouldContinue === false) {
                 response.destroy();
@@ -230,10 +243,16 @@ async function sendProviderRequest(request) {
               if (size > limit) throw new BodyTooLargeError(response.statusCode ?? 0, response.headers);
               chunks.push(chunk);
             }
+            if (isBodyTooLarge) {
+              reject(new BodyTooLargeError(response.statusCode ?? 0, response.headers));
+              return;
+            }
             resolve({ status: response.statusCode ?? 0, headers: response.headers, body: Buffer.concat(chunks) });
           } catch (error) {
             response.destroy();
-            if (request.ignoreErrorBodyReadFailure && ((response.statusCode ?? 0) < 200 || (response.statusCode ?? 0) >= 300)) {
+            if (isBodyTooLarge) {
+              reject(new BodyTooLargeError(response.statusCode ?? 0, response.headers));
+            } else if (request.ignoreErrorBodyReadFailure && ((response.statusCode ?? 0) < 200 || (response.statusCode ?? 0) >= 300)) {
               resolve({ status: response.statusCode ?? 0, headers: response.headers, body: Buffer.concat(chunks) });
             } else {
               reject(error instanceof BodyTooLargeError || error instanceof ProviderStalledError ? error : new ProviderTransportError(false));
@@ -258,7 +277,7 @@ async function sendProviderRequest(request) {
     });
     clientRequest.on("error", (error) => {
       if (responseStallTimer) clearTimeout(responseStallTimer);
-      reject(error instanceof ProviderStalledError ? error : new ProviderTransportError(!hasConnected && !hasWrittenRequest));
+      if (!hasReceivedResponse) reject(error instanceof ProviderStalledError ? error : new ProviderTransportError(!hasConnected && !hasWrittenRequest));
     });
     if (request.stallTimeoutMs && request.stallTimeoutMs > 0) responseStallTimer = setTimeout(() => clientRequest.destroy(new ProviderStalledError()), request.stallTimeoutMs);
     try {

package/dist/oauthtoken/index.d.ts

@@ -19,7 +19,7 @@ interface ManifestCredentialRefreshOptions {
  * Missing expiry keeps an existing access token. Refresh sends each active grant
  * and reports the earliest expiry. Declared sub-500 terminal errors require
  * reauthorization; other token endpoint failures remain retryable. A credential
- * with multiple methods must carry authMethodId.
+ * with multiple methods uses the declared default when authMethodId is empty.
  */
 declare class ManifestCredentialRefreshDriver<C extends object> implements CredentialRefreshDriver<C> {
     #private;

package/dist/oauthtoken/index.js

@@ -47,7 +47,7 @@ var ManifestCredentialRefreshDriver = class {
       if (grant.refreshField && !this.#credentialValue(credentials, grant.refreshField)) continue;
       const token = await this.#exchange(grant, credentials, method, signal);
       const requiredScopes = this.#scopes(grant.scopes).filter((scope) => grant.kind !== "refresh" || scope !== "offline_access");
-      if (grants.length > 1 ? !hasExactScopes(token.scope, requiredScopes) : token.scope !== "" && !hasAllScopes(token.scope, requiredScopes)) throw new ReauthorizationRequiredError();
+      if (grant.exactScopes ? !hasDeclaredScopes(token.scope, requiredScopes, grant.scopeSeparators, true) : token.scope.trim() !== "" && !hasDeclaredScopes(token.scope, requiredScopes, grant.scopeSeparators, false)) throw new ReauthorizationRequiredError();
       const updates = {};
       for (const mapping of grant.mappings) {
         const destination = manifestText(mapping.credential);
@@ -75,7 +75,6 @@ var ManifestCredentialRefreshDriver = class {
     const methods = manifestList(this.#auth.methods);
     if (!methods.length) return this.#auth;
     const selected = manifestText(credentials.authMethodId);
-    if (!selected && methods.length > 1) throw new ReauthorizationRequiredError();
     const method = methods.map(manifestObject).find((item) => item.id === (selected || manifestText(this.#auth.defaultMethod)));
     if (!method) throw new ReauthorizationRequiredError();
     return method;
@@ -102,11 +101,15 @@ var ManifestCredentialRefreshDriver = class {
         assertion: {},
         mappings: manifestList(declaration.credentialMappings).map(manifestObject),
         copies: [],
-        scopes: declaration.grantedScopes === "userScopes" ? oauth.userScopes : oauth.scopes,
+        scopes: declaration.grantedScopes === "userScopes" ? oauth.userScopes : refresh?.requiredScopes ?? oauth.scopes,
         requestScopes: [],
         terminalCodes: strings(refresh?.terminalErrorCodes, ["invalid_grant"]),
         acceptedTokenTypes: strings(declaration.acceptedTokenTypes ?? refresh?.acceptedTokenTypes, ["Bearer"]),
-        acceptsMissingTokenType: refresh?.acceptsMissingTokenType === true,
+        exactScopes: declaration.exactScopes === true || declaration.exactScopes === void 0 && refresh?.exactScopes === true,
+        scopeSeparators: refresh?.scopeSeparators === "whitespaceAndComma" ? "whitespaceAndComma" : "whitespace",
+        allowsPublicClient: refresh?.allowsPublicClient === true,
+        acceptsMissingTokenType: declaration.acceptsMissingTokenType === void 0 ? refresh?.acceptsMissingTokenType === true : declaration.acceptsMissingTokenType === true,
+        acceptsMissingExpiresIn: refresh?.missingExpiry !== void 0,
         missingExpiry: missingExpiryLifetime(refresh?.missingExpiry),
         additionalParameters: stringRecord(refresh?.additionalParameters)
       }));
@@ -129,7 +132,11 @@ var ManifestCredentialRefreshDriver = class {
         requestScopes: client.scopes,
         terminalCodes: strings(client.terminalErrorCodes, ["invalid_client"]),
         acceptedTokenTypes: strings(client.acceptedTokenTypes, ["Bearer"]),
+        exactScopes: false,
+        scopeSeparators: "whitespace",
+        allowsPublicClient: false,
         acceptsMissingTokenType: client.acceptsMissingTokenType === true,
+        acceptsMissingExpiresIn: client.missingExpiry !== void 0,
         missingExpiry: missingExpiryLifetime(client.missingExpiry),
         additionalParameters: stringRecord(client.additionalParameters)
       }];
@@ -153,7 +160,11 @@ var ManifestCredentialRefreshDriver = class {
       requestScopes: [],
       terminalCodes: strings(bearer.terminalErrorCodes, ["invalid_grant"]),
       acceptedTokenTypes: strings(bearer.acceptedTokenTypes, ["Bearer"]),
+      exactScopes: false,
+      scopeSeparators: "whitespace",
+      allowsPublicClient: false,
       acceptsMissingTokenType: bearer.acceptsMissingTokenType === true,
+      acceptsMissingExpiresIn: bearer.missingExpiry !== void 0,
       missingExpiry: missingExpiryLifetime(bearer.missingExpiry),
       additionalParameters: {}
     }];
@@ -173,7 +184,7 @@ var ManifestCredentialRefreshDriver = class {
       terminalErrorCodes: grant.terminalCodes,
       acceptedTokenTypes: grant.acceptedTokenTypes,
       acceptsMissingTokenType: grant.acceptsMissingTokenType,
-      acceptsMissingExpiresIn: true,
+      acceptsMissingExpiresIn: grant.acceptsMissingExpiresIn,
       usesJSONRequestBody: grant.encoding === "json",
       additionalRequestParameters: grant.additionalParameters,
       credentialMappingPaths: grant.mappings.map((mapping) => manifestText(mapping.source)),
@@ -198,7 +209,8 @@ var ManifestCredentialRefreshDriver = class {
       return await endpoint.exchangeJWTBearerAssertion(signed, signal);
     }
     const secret = this.#credentialValue(credentials, grant.clientSecret);
-    if (!secret && this.#isRequired(method, grant.clientSecret)) throw new ReauthorizationRequiredError();
+    if (!secret && !grant.allowsPublicClient && (grant.kind === "refresh" || this.#isRequired(method, grant.clientSecret)))
+      throw new ReauthorizationRequiredError();
     const authenticationMethod = secret || grant.kind === "client_credentials" ? this.#resolveSource(grant.authentication, credentials, key) : "none";
     const client = { id: this.#credentialValue(credentials, grant.clientID), secret: new SecretString(secret), authenticationMethod };
     if (grant.kind === "refresh") {
@@ -228,8 +240,10 @@ var ManifestCredentialRefreshDriver = class {
       if (!this.#credentialFields[manifestText(copy.credential)] || !this.#credentialFields[manifestText(copy.fromCredential)])
         throw new TypeError("manifest credential field is not mapped");
     }
-    parseDurationMs(grant.missingExpiry);
-    if (grant.kind === "jwt_bearer") parseDurationMs(manifestText(grant.assertion.lifetime));
+    if (grant.missingExpiry && parseDurationMs(grant.missingExpiry) <= 0)
+      throw new TypeError("manifest grant duration must be positive");
+    if (grant.kind === "jwt_bearer" && parseDurationMs(manifestText(grant.assertion.lifetime)) < 1)
+      throw new TypeError("manifest JWT assertion lifetime must be at least one millisecond");
   }
   #scopes(source) {
     if (Array.isArray(source)) return source.filter((value) => typeof value === "string");
@@ -274,37 +288,43 @@ function stringRecord(value) {
 function missingExpiryLifetime(value) {
   return manifestText(manifestObject(value).lifetime);
 }
+function hasDeclaredScopes(returnedScopes, requiredScopes, separators, exact) {
+  const granted = new Set(returnedScopes.split(separators === "whitespaceAndComma" ? /[ ,]+/ : /\s+/).filter(Boolean));
+  const required = new Set(requiredScopes);
+  return (!exact || granted.size === required.size) && [...required].every((scope) => granted.has(scope));
+}
 function pathEscape(value) {
   return encodeURIComponent(value).replace(/[!'()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`).replace(/%(?:2B|26|3D|3A|40|24)/g, (escaped) => ({ "%2B": "+", "%26": "&", "%3D": "=", "%3A": ":", "%40": "@", "%24": "$" })[escaped] ?? escaped);
 }
-function hasExactScopes(returnedScopes, requiredScopes) {
-  const granted = new Set(returnedScopes.split(/[\s,]+/).filter(Boolean));
-  const required = new Set(requiredScopes);
-  return granted.size === required.size && [...required].every((scope) => granted.has(scope));
-}
 function parseDurationMs(value) {
   if (!value) return 0;
-  const parts = value.matchAll(/(\d+(?:\.\d+)?)(ns|us|µs|μs|ms|s|m|h)/g);
-  const milliseconds = {
-    ns: 1e-6,
-    us: 1e-3,
-    "\xB5s": 1e-3,
-    "\u03BCs": 1e-3,
-    ms: 1,
-    s: 1e3,
-    m: 6e4,
-    h: 36e5
+  if (value === "0" || value === "+0" || value === "-0") return 0;
+  const sign2 = value[0] === "-" ? -1n : 1n;
+  const magnitude = value[0] === "+" || value[0] === "-" ? value.slice(1) : value;
+  const parts = magnitude.matchAll(/((?:\d+(?:\.\d*)?|\.\d+))(ns|us|µs|μs|ms|s|m|h)/g);
+  const nanoseconds = {
+    ns: 1n,
+    us: 1000n,
+    "\xB5s": 1000n,
+    "\u03BCs": 1000n,
+    ms: 1000000n,
+    s: 1000000000n,
+    m: 60000000000n,
+    h: 3600000000000n
   };
-  let duration = 0;
+  let duration = 0n;
   let position = 0;
   for (const part of parts) {
     if (part.index !== position) throw new TypeError("manifest grant duration is invalid");
-    duration += Number(part[1]) * milliseconds[part[2]];
+    const [whole, fraction = ""] = part[1].split(".");
+    const unit = nanoseconds[part[2]];
+    duration += BigInt(whole || "0") * unit;
+    if (fraction) duration += BigInt(fraction) * unit / 10n ** BigInt(fraction.length);
     position += part[0].length;
   }
-  if (position !== value.length || duration <= 0 || !Number.isFinite(duration) || duration > Number.MAX_SAFE_INTEGER)
+  if (position !== magnitude.length || duration === 0n || duration > (sign2 < 0n ? 9223372036854775808n : 9223372036854775807n))
     throw new TypeError("manifest grant duration is invalid");
-  return duration;
+  return Number(sign2 * duration) / 1e6;
 }
 
 // src/oauthtoken/index.ts
@@ -514,7 +534,7 @@ function hasAllScopes(returnedScope, requiredScopes) {
   const granted = new Set(returnedScope.split(/[ ,]+/).filter(Boolean));
   return requiredScopes.every((scope) => granted.has(scope));
 }
-function hasExactScopes2(returnedScope, requiredScopes) {
+function hasExactScopes(returnedScope, requiredScopes) {
   const granted = new Set(returnedScope.split(/[ ,]+/).filter(Boolean));
   return granted.size === new Set(requiredScopes).size && hasAllScopes(returnedScope, requiredScopes);
 }
@@ -548,7 +568,7 @@ export {
   TokenResponse,
   forcedRefreshFloorMs,
   hasAllScopes,
-  hasExactScopes2 as hasExactScopes,
+  hasExactScopes,
   isRefreshRequired,
   isRefreshRequiredWithIssueTime,
   parseRSAPrivateKeyPEM,

package/dist/projectconfig/index.js

@@ -6,7 +6,7 @@ import {
   isLocalStorageHost,
   isPrivateBrokerHost,
   readBoundedBody
-} from "../chunk-BG65RPGH.js";
+} from "../chunk-UWB627CI.js";
 import {
   ReauthorizationRequiredError
 } from "../chunk-IHG6ADQG.js";

package/dist/providerhttp/index.d.ts

@@ -44,7 +44,8 @@ interface ProviderRequest {
     /** Request headers, including provider credentials when needed. */ headers?: Record<string, string>;
     /** Caller-encoded request body. */ body?: Uint8Array;
     /** Maximum response body size in bytes. */ maxResponseBytes: number;
-    /** Optional separate prefix limit for non-2xx error bodies. */ maxErrorResponseBytes?: number;
+    /** On a response limit, destroy the connection (default) or drain to EOF before rejecting. Drain requires a positive timeoutMs, positive stallTimeoutMs, or signal. */ onBodyLimit?: 'destroy' | 'drain';
+    /** Optional separate prefix limit for non-2xx error bodies; when set, its truncation takes precedence over drain. */ maxErrorResponseBytes?: number;
     /** Classify a non-2xx status even when its diagnostic body fails to read. */ ignoreErrorBodyReadFailure?: boolean;
     /** Network policy checked against all resolved addresses. */ addressPolicy: AddressPolicy;
     /** Request deadline in milliseconds. */ timeoutMs?: number;

package/dist/providerhttp/index.js

@@ -11,7 +11,7 @@ import {
   readErrorTokens,
   sendProviderRequest,
   validateBaseURL
-} from "../chunk-BG65RPGH.js";
+} from "../chunk-UWB627CI.js";
 export {
   AddressRefusal,
   BodyTooLargeError,

package/dist/textgen/index.js

@@ -37,7 +37,7 @@ import {
   readErrorTokens,
   sendProviderRequest,
   validateBaseURL
-} from "../chunk-BG65RPGH.js";
+} from "../chunk-UWB627CI.js";
 import "../chunk-IHG6ADQG.js";
 
 // src/textgen/contract.ts

package/dist/textgen/openaichat/index.js

@@ -5,7 +5,7 @@ import {
 } from "../../chunk-466BPS3M.js";
 import {
   readErrorTokens
-} from "../../chunk-BG65RPGH.js";
+} from "../../chunk-UWB627CI.js";
 import "../../chunk-IHG6ADQG.js";
 
 // src/textgen/openaichat/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superdurable/connectors-sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Provider-neutral TypeScript contracts for Dex connectors",
   "repository": {
     "type": "git",