brass-runtime 1.19.2 → 1.21.0

package/dist/agent/index.mjs

@@ -1,13 +1,17 @@
 import {
   AGENT_CONFIG_FILE_NAMES,
+  CI_INDICATORS,
   NodeShell,
   PROJECT_LOCKFILE_PROBES,
   PROJECT_PROFILE_PROBES,
   autoApproveApprovals,
+  buildHostProfile,
   canAutoRollback,
   canRequestPatchRepair,
+  collectHostSignals,
   commandForScript,
   decideNextAction,
+  deepFreeze,
   defaultPermissions,
   deriveContextSearchQueries,
   describeCommandDiscovery,
@@ -27,6 +31,10 @@ import {
   extractPatchPaths,
   extractUnifiedDiff,
   goalForAgentPreset,
+  inferCapabilities,
+  inferConstraints,
+  inferOptionalIdentity,
+  inferTransport,
   inferUserLanguage,
   initialAgentState,
   invokeAction,
@@ -73,7 +81,7 @@ import {
   timeout,
   unappliedPatchStack,
   workspaceValidationStatus
-} from "../chunk-6BNZS2A4.mjs";
+} from "../chunk-Q57ENQUW.mjs";
 import "../chunk-B5JD23U7.mjs";
 import "../chunk-BFNBU47C.mjs";
 import "../chunk-36I3M4UC.mjs";
@@ -81,14 +89,18 @@ import "../chunk-UZQ3BB6W.mjs";
 import "../chunk-Y6FXYEAI.mjs";
 export {
   AGENT_CONFIG_FILE_NAMES,
+  CI_INDICATORS,
   NodeShell,
   PROJECT_LOCKFILE_PROBES,
   PROJECT_PROFILE_PROBES,
   autoApproveApprovals,
+  buildHostProfile,
   canAutoRollback,
   canRequestPatchRepair,
+  collectHostSignals,
   commandForScript,
   decideNextAction,
+  deepFreeze,
   defaultPermissions,
   deriveContextSearchQueries,
   describeCommandDiscovery,
@@ -108,6 +120,10 @@ export {
   extractPatchPaths,
   extractUnifiedDiff,
   goalForAgentPreset,
+  inferCapabilities,
+  inferConstraints,
+  inferOptionalIdentity,
+  inferTransport,
   inferUserLanguage,
   initialAgentState,
   invokeAction,

package/dist/{chunk-QAHW7S3Q.cjs → chunk-62IBGQOU.cjs}

@@ -4,7 +4,7 @@
 var _chunkJQCQWO47cjs = require('./chunk-JQCQWO47.cjs');
 
 
-var _chunkTWEHIAUEcjs = require('./chunk-TWEHIAUE.cjs');
+var _chunkBDTBIYAMcjs = require('./chunk-BDTBIYAM.cjs');
 
 
 var _chunkZJC3JZIEcjs = require('./chunk-ZJC3JZIE.cjs');
@@ -14,7 +14,7 @@ var _chunkVXNWVAIGcjs = require('./chunk-VXNWVAIG.cjs');
 
 
 
-var _chunkUOKXJQAIcjs = require('./chunk-UOKXJQAI.cjs');
+var _chunkLA2PAO7Jcjs = require('./chunk-LA2PAO7J.cjs');
 
 
 
@@ -862,24 +862,24 @@ function baseHttpConfig(baseUrl, scenario) {
   };
 }
 function makeWireClient(baseUrl, scenario) {
-  return _chunkUOKXJQAIcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
+  return _chunkLA2PAO7Jcjs.makeHttp.call(void 0, baseHttpConfig(baseUrl, scenario));
 }
 function makeMinimalClient(baseUrl, scenario) {
-  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkLA2PAO7Jcjs.makeDefaultHttpClient.call(void 0, {
     preset: "minimal",
     compression: false,
     ...baseHttpConfig(baseUrl, scenario)
   });
 }
 function makeDefaultClient(baseUrl, scenario, preset, disableAdaptiveLimiter, observability) {
-  return _chunkUOKXJQAIcjs.makeDefaultHttpClient.call(void 0, {
+  return _chunkLA2PAO7Jcjs.makeDefaultHttpClient.call(void 0, {
     preset,
     compression: false,
     ...baseHttpConfig(baseUrl, scenario),
     ...disableAdaptiveLimiter ? { adaptiveLimiter: false } : {},
     ...observability ? {
       middleware: [
-        _chunkTWEHIAUEcjs.withHttpObservability.call(void 0, {
+        _chunkBDTBIYAMcjs.withHttpObservability.call(void 0, {
           metrics: observability.metrics,
           logs: false,
           spans: {},

package/dist/{chunk-6AGAZD32.js → chunk-6LF3M4JC.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RZQK32C6.js";
 import {
   withHttpObservability
-} from "./chunk-BHX4MD35.js";
+} from "./chunk-VXZIP3IU.js";
 import {
   makeObservability
 } from "./chunk-TAPB4NN5.js";
@@ -14,7 +14,7 @@ import {
 import {
   makeDefaultHttpClient,
   makeHttp
-} from "./chunk-HKLZJ5UK.js";
+} from "./chunk-POH2WZBI.js";
 import {
   Runtime,
   Scheduler

package/dist/{chunk-5X3MPWTR.mjs → chunk-6NXQL3IC.mjs}

@@ -5638,14 +5638,14 @@ function noopInvalidate(_key) {
 }
 function noopClear() {
 }
-function buildLifecycleClient(fn2, tracker, internals) {
-  const client = (req) => trackRequest(fn2, req, tracker, internals);
+function buildLifecycleClient(fn3, tracker, internals) {
+  const client = (req) => trackRequest(fn3, req, tracker, internals);
   const stats = () => {
     tracker.setQueueDepth(internals.queueDepth?.() ?? 0);
     return tracker.snapshot();
   };
   const withMw = (mw) => {
-    const wrappedFn = mw(withLifecycleMetadata(fn2, internals));
+    const wrappedFn = mw(withLifecycleMetadata(fn3, internals));
     return buildLifecycleClient(wrappedFn, tracker, internals);
   };
   const lifecycleClient = Object.assign(client, {
@@ -5661,9 +5661,9 @@ function buildLifecycleClient(fn2, tracker, internals) {
   });
   return lifecycleClient;
 }
-function withLifecycleMetadata(fn2, internals) {
-  if (!internals.adaptiveLimiter) return fn2;
-  return Object.assign(((req) => fn2(req)), {
+function withLifecycleMetadata(fn3, internals) {
+  if (!internals.adaptiveLimiter) return fn3;
+  return Object.assign(((req) => fn3(req)), {
     adaptiveLimiter: internals.adaptiveLimiter
   });
 }
@@ -5684,7 +5684,7 @@ function shutdownClient(activeCancelers, prewarmMgr, wireShutdown) {
   wireShutdown?.();
   return asyncSucceed(void 0);
 }
-function trackRequest(fn2, req, tracker, internals) {
+function trackRequest(fn3, req, tracker, internals) {
   return {
     _tag: "Async",
     register: (env, cb) => {
@@ -5746,7 +5746,7 @@ function trackRequest(fn2, req, tracker, internals) {
         return () => void 0;
       }
       try {
-        cancelInner = registerHttpEffect(fn2(req), env, finish);
+        cancelInner = registerHttpEffect(fn3(req), env, finish);
       } catch (error) {
         finish({
           _tag: "Failure",
@@ -6168,6 +6168,190 @@ function previewJson(value) {
   }
 }
 
+// src/http/bareMetalClient.ts
+var fn2 = Schema.custom(
+  (value) => typeof value === "function",
+  "function"
+);
+var poolConfig2 = Schema.union([
+  Schema.literal(false),
+  Schema.object(
+    {
+      concurrency: Schema.number({ min: 1, int: true }).optional(),
+      maxQueue: Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
+      key: Schema.union([
+        Schema.enum(["global", "origin", "host"]),
+        fn2
+      ]).optional(),
+      engine: Schema.enum(["ts", "wasm"]).optional(),
+      wasm: Schema.boolean().optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var adaptiveLimiterConfig2 = Schema.union([
+  Schema.literal(false),
+  Schema.object(
+    {
+      preset: Schema.enum(["conservative", "balanced", "aggressive"]).optional(),
+      initialLimit: Schema.number({ min: 1, int: true }).optional(),
+      minLimit: Schema.number({ min: 1, int: true }).optional(),
+      maxLimit: Schema.number({ min: 1, int: true }).optional(),
+      smoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "smoothingFactor must be in (0, 1]").optional(),
+      probeInterval: Schema.number({ min: 1, int: true }).optional(),
+      probeJitterRatio: Schema.number({ min: 0, max: 1 }).optional(),
+      windowSize: Schema.number({ min: 2, int: true }).optional(),
+      minSamples: Schema.number({ min: 1, int: true }).optional(),
+      baselineStrategy: Schema.enum(["min", "p5", "ema-low"]).optional(),
+      decreaseCooldownSamples: Schema.number({ min: 0, int: true }).optional(),
+      historySize: Schema.number({ min: 0, int: true }).optional(),
+      windowDecayFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "windowDecayFactor must be in (0, 1]").optional(),
+      errorWeight: Schema.number({ min: 0, max: 1 }).optional(),
+      errorSmoothingFactor: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "errorSmoothingFactor must be in (0, 1]").optional(),
+      errorStatusThreshold: Schema.number({ min: 100, max: 599, int: true }).optional(),
+      queueStrategy: Schema.enum(["fifo", "priority"]).optional(),
+      queueLoadShedding: Schema.enum(["reject-new", "priority-evict"]).optional(),
+      rejectionBackoffThreshold: Schema.number({ min: 1, int: true }).optional(),
+      rejectionBackoffMs: Schema.number({ min: 1, int: true }).optional(),
+      stateTtlMs: Schema.union([Schema.literal(false), Schema.number({ min: 1, int: true })]).optional(),
+      warmupRequests: Schema.number({ min: 0, int: true }).optional(),
+      decreaseThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "decreaseThreshold must be in (0, 1]").optional(),
+      increaseThreshold: Schema.number({ min: 1 }).optional(),
+      maxDecreaseRatio: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "maxDecreaseRatio must be in (0, 1]").optional(),
+      headroomStrategy: Schema.union([
+        Schema.number({ min: 1 }),
+        Schema.enum(["fixed", "proportional"]),
+        fn2,
+        Schema.object({ type: Schema.literal("fixed"), value: Schema.number({ min: 1 }).optional() }, { unknownKeys: "passthrough" }),
+        Schema.object({
+          type: Schema.literal("proportional"),
+          ratio: Schema.number({ min: 0 }).refine((n) => n > 0, "ratio must be > 0").optional(),
+          min: Schema.number({ min: 1 }).optional(),
+          max: Schema.number({ min: 1 }).optional()
+        }, { unknownKeys: "passthrough" })
+      ]).optional(),
+      slowStartRecovery: Schema.boolean().optional(),
+      slowStartSaturationThreshold: Schema.number({ min: 0, max: 1 }).refine((n) => n > 0, "slowStartSaturationThreshold must be in (0, 1]").optional(),
+      slowStartSaturationSamples: Schema.number({ min: 1, int: true }).optional(),
+      key: Schema.union([Schema.enum(["global", "origin", "host"]), fn2]).optional(),
+      maxQueue: Schema.number({ min: 0, int: true }).optional(),
+      queueTimeoutMs: Schema.number({ min: 1, int: true }).optional(),
+      onLimitChange: fn2.optional(),
+      percentile: Schema.enum(["p50", "p99"]).optional()
+    },
+    { unknownKeys: "passthrough" }
+  )
+]);
+var bareMetalConfigSchema = Schema.object(
+  {
+    baseUrl: Schema.string().optional(),
+    headers: Schema.record(Schema.string()).optional(),
+    timeoutMs: Schema.number({ min: 1, int: true }).optional(),
+    transport: fn2.optional(),
+    streamTransport: fn2.optional(),
+    pool: poolConfig2.optional(),
+    adaptiveLimiter: adaptiveLimiterConfig2.optional(),
+    onEvent: fn2.optional()
+  },
+  { unknownKeys: "passthrough" }
+);
+function validateBareMetalConfig(config) {
+  parseConfig("BareMetalHttpConfig", bareMetalConfigSchema, config);
+}
+var transportDestroy2 = (transport) => {
+  const destroy = transport.destroy;
+  return typeof destroy === "function" ? () => destroy.call(transport) : void 0;
+};
+function makeBareMetalHttp(cfg = {}) {
+  validateBareMetalConfig(cfg);
+  const baseUrl = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = cfg.transport ?? makeFetchTransport();
+  const destroyTransport = transportDestroy2(transport);
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return asyncFail(url);
+    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
+    if (!adaptiveLimiter && !pool && timeoutMs === void 0) {
+      return runDirectTransport(req, url, transport, metrics);
+    }
+    return runPoolTransport(req, url, transport, metrics, pool, adaptiveLimiter, void 0, timeoutMs);
+  };
+  const metadata = {};
+  if (adaptiveLimiter) metadata.adaptiveLimiter = adaptiveLimiter;
+  if (adaptiveLimiter || destroyTransport) {
+    metadata.destroy = () => {
+      adaptiveLimiter?.destroy();
+      destroyTransport?.();
+    };
+    metadata.shutdown = () => {
+      adaptiveLimiter?.shutdown();
+      destroyTransport?.();
+    };
+  }
+  return decorate(run, metrics.snapshot, metadata);
+}
+function makeBareMetalHttpStream(cfg = {}) {
+  validateBareMetalConfig(cfg);
+  const baseUrl = cfg.baseUrl ?? "";
+  const defaultHeaders = cfg.headers ?? {};
+  const normalize = normalizeRequest(defaultHeaders);
+  const adaptiveLimiter = makeAdaptiveLimiter(cfg);
+  const pool = adaptiveLimiter ? void 0 : makePool(cfg);
+  const metrics = makeHttpStats(pool, adaptiveLimiter);
+  const transport = cfg.streamTransport ?? makeFetchStreamTransport();
+  const run = (req0) => {
+    const req = normalize(req0);
+    const url = resolveRequestUrl(req, baseUrl);
+    if (!(url instanceof URL)) return asyncFail(url);
+    const timeoutMs = resolvePositiveTimeout(req.timeoutMs ?? cfg.timeoutMs);
+    return fromPromiseAbortable(
+      async (signal, env) => {
+        let lease;
+        const linkedSignal = linkAbortSignals(signal, req.init?.signal);
+        try {
+          if (linkedSignal.signal.aborted) throw abortErrorForSignal(linkedSignal.signal);
+          if (adaptiveLimiter) {
+            const key = resolveHttpPoolKey(adaptiveLimiter.keyResolver, req, url);
+            lease = await adaptiveLimiter.acquire(key, linkedSignal.signal, { priority: requestPriority(req) });
+          } else if (pool) {
+            const key = resolveHttpPoolKey(pool.keyResolver, req, url);
+            lease = await pool.acquire(key, linkedSignal.signal);
+          }
+          const response = await runTransportEffect(
+            transport({ request: req, url, signal: linkedSignal.signal }),
+            env,
+            linkedSignal.signal
+          );
+          releaseSuccess(lease, adaptiveLimiter, response);
+          lease = void 0;
+          return response;
+        } finally {
+          linkedSignal.cleanup();
+          if (lease) {
+            releaseFailure(lease, adaptiveLimiter);
+          }
+        }
+      },
+      normalizeHttpError,
+      {
+        label: fetchLabel(req, url),
+        timeoutMs,
+        timeoutReason: timeoutMs ? () => timeoutReason(req, url, timeoutMs) : void 0,
+        onStart: metrics.onStart,
+        onFinish: metrics.onFinish
+      }
+    );
+  };
+  return decorateStream(run, metrics.snapshot);
+}
+
 // src/http/requestBuilder.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function splitHttpRequestInit(init) {
@@ -6265,7 +6449,8 @@ var PRESET_CONFIGS = {
   highThroughputProxy: PROXY_PRESET_CONFIG,
   balanced: BALANCED_PRESET_CONFIG,
   default: DEFAULT_PRESET_CONFIG,
-  production: DEFAULT_PRESET_CONFIG
+  production: DEFAULT_PRESET_CONFIG,
+  bareMetal: {}
 };
 function isDefaultCacheableResponse(req, res) {
   if (!DEFAULT_CACHEABLE_METHODS.has(req.method)) return false;
@@ -6292,6 +6477,9 @@ function makeDefaultHttpClient(config = {}) {
     policyPresets,
     ...lifecycleOverrides
   } = config;
+  if (preset === "bareMetal") {
+    return buildBareMetalBranch(lifecycleOverrides, middleware, config);
+  }
   const lifecycleConfig2 = mergeLifecycleConfig(PRESET_CONFIGS[preset], lifecycleOverrides);
   let wire = makeLifecycleClient(lifecycleConfig2);
   const compressionResult = compression === false || compression === void 0 && isLeanPreset(preset) ? void 0 : makeCompressionMiddleware(compression === void 0 ? void 0 : compression);
@@ -6315,6 +6503,160 @@ function makeDefaultHttpClient(config = {}) {
     useInlineDecode
   });
 }
+var LIFECYCLE_KEYS = [
+  "dedup",
+  "batch",
+  "cache",
+  "priority",
+  "retry",
+  "prewarm",
+  "adaptiveLimiter",
+  "compression"
+];
+function findIgnoredLifecycleKeys(overrides) {
+  const found = [];
+  for (const key of LIFECYCLE_KEYS) {
+    if (key in overrides && overrides[key] !== void 0 && overrides[key] !== false) {
+      found.push(key);
+    }
+  }
+  return found;
+}
+function extractBareMetalConfig(config) {
+  return {
+    baseUrl: config.baseUrl,
+    headers: config.headers,
+    timeoutMs: config.timeoutMs,
+    transport: config.transport,
+    streamTransport: config.streamTransport,
+    pool: config.pool,
+    adaptiveLimiter: void 0,
+    // bare-metal ignores adaptiveLimiter from lifecycle overrides
+    onEvent: config.onEvent
+  };
+}
+function buildBareMetalBranch(lifecycleOverrides, middleware, config) {
+  const ignored = findIgnoredLifecycleKeys(lifecycleOverrides);
+  if (ignored.length > 0 && config.onEvent) {
+    config.onEvent({
+      type: "warning",
+      message: `bareMetal preset ignores: ${ignored.join(", ")}`
+    });
+  }
+  let bareWire = makeBareMetalHttp(extractBareMetalConfig(config));
+  for (const mw of middleware) {
+    bareWire = bareWire.with(mw);
+  }
+  const features = Object.freeze({
+    dedup: false,
+    batch: false,
+    cache: false,
+    priority: false,
+    retry: false,
+    prewarm: false,
+    adaptiveLimiter: false,
+    compression: false,
+    middleware: middleware.length
+  });
+  return buildBareMetalDefaultClient(bareWire, { preset: "bareMetal", features });
+}
+function buildBareMetalDefaultClient(bareWire, meta) {
+  const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
+  const requestRaw = (req) => bareWire(req);
+  const request = (req) => withPromise(requestRaw(req));
+  const get = (url, init) => request(buildHttpRequest("GET", url, init));
+  const post = (url, body, init) => request(buildHttpRequest("POST", url, init, body));
+  const getText = (url, init) => {
+    const req = buildHttpRequest("GET", url, init);
+    return withPromise(
+      mapTryAsync(requestRaw(req), (w) => toResponse(w, w.bodyText))
+    );
+  };
+  const getJson = ((url, init) => {
+    const req = setHeaderIfMissing("accept", "application/json")(
+      buildHttpRequest("GET", url, init)
+    );
+    return withPromise(
+      asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName))
+    );
+  });
+  const postJson = ((url, bodyObj, init) => {
+    return withPromise(
+      asyncFlatMap(
+        encodeJsonBodyEffect(bodyObj, init?.bodySchema, { schemaName: init?.bodySchemaName }),
+        (bodyText) => {
+          const req = setHeaderIfMissing("content-type", "application/json")(
+            setHeaderIfMissing("accept", "application/json")(
+              buildHttpRequest("POST", url, init, bodyText)
+            )
+          );
+          return asyncFlatMap(requestRaw(req), (w) => decodeResponse(w, init?.schema, init?.schemaName));
+        }
+      )
+    );
+  });
+  const wireAsLifecycle = Object.assign(
+    (req) => bareWire(req),
+    {
+      with: (mw) => {
+        const newBare = bareWire.with(mw);
+        return buildBareMetalDefaultClient(newBare, {
+          ...meta,
+          features: { ...meta.features, middleware: meta.features.middleware + 1 }
+        }).wire;
+      },
+      stats: () => ({
+        cacheHits: 0,
+        cacheMisses: 0,
+        cacheEvictions: 0,
+        dedupHits: 0,
+        dedupActive: 0,
+        queueDepth: 0,
+        requestsStarted: 0,
+        requestsCompleted: 0,
+        requestsFailed: 0,
+        retries: 0,
+        batchDispatches: 0,
+        batchedRequests: 0,
+        wire: bareWire.stats()
+      }),
+      cancelAll: () => asyncSucceed(void 0),
+      shutdown: () => {
+        bareWire.shutdown?.();
+        return asyncSucceed(void 0);
+      },
+      cache: {
+        invalidate: () => {
+        },
+        clear: () => {
+        }
+      },
+      ...bareWire.adaptiveLimiter ? { adaptiveLimiter: bareWire.adaptiveLimiter } : {}
+    }
+  );
+  return {
+    request,
+    get,
+    post,
+    getText,
+    getJson,
+    postJson,
+    with: (mw) => buildBareMetalDefaultClient(bareWire.with(mw), {
+      ...meta,
+      features: {
+        ...meta.features,
+        middleware: meta.features.middleware + 1
+      }
+    }),
+    wire: wireAsLifecycle,
+    stats: () => wireAsLifecycle.stats(),
+    cache: wireAsLifecycle.cache,
+    cancelAll: wireAsLifecycle.cancelAll,
+    shutdown: wireAsLifecycle.shutdown,
+    preset: meta.preset,
+    features: meta.features
+  };
+}
 function buildDefaultClient(wire, meta) {
   const withPromise = (eff) => withAsyncPromise((e, env) => toPromise(e, env))(eff);
   const requestRaw = (req) => wire(req);
@@ -6495,7 +6837,7 @@ function isEnabled(value) {
   return value !== void 0 && value !== false;
 }
 function isLeanPreset(preset) {
-  return preset === "minimal" || preset === "proxy" || preset === "highThroughputProxy";
+  return preset === "minimal" || preset === "proxy" || preset === "highThroughputProxy" || preset === "bareMetal";
 }
 
 // src/http/layer.ts
@@ -6573,9 +6915,24 @@ export {
   makeFetchStreamTransport,
   decorate,
   withMiddleware,
+  decorateStream,
   normalizeHeadersInit,
+  normalizeRequest,
+  resolvePositiveTimeout,
+  makeHttpStats,
+  makePool,
+  makeAdaptiveLimiter,
+  resolveRequestUrl,
+  fetchLabel,
+  timeoutReason,
+  requestPriority,
+  runTransportEffect,
+  runDirectTransport,
+  releaseSuccess,
+  releaseFailure,
   makeHttpStream,
   noopSignal,
+  runPoolTransport,
   makeHttp,
   withRetryStream,
   SEPARATOR,
@@ -6611,6 +6968,9 @@ export {
   validatedJson,
   validatedJsonResponse,
   buildHttpRequest,
+  validateBareMetalConfig,
+  makeBareMetalHttp,
+  makeBareMetalHttpStream,
   defaultHttpClientPreset,
   makeDefaultHttpClient,
   HttpClientService,