brass-runtime 1.18.1 → 1.19.0

package/dist/{chunk-YGR2IN4R.js → chunk-JWFOWPMB.js}

@@ -1,6 +1,6 @@
 import {
   RuntimeService
-} from "./chunk-LSYQ3C2M.js";
+} from "./chunk-FC5N5QHJ.js";
 import {
   exemplarFromTraceContext,
   injectTraceContext,
@@ -13,33 +13,29 @@ import {
   spanEvent,
   validateHttpObservabilityOptions,
   withSpan
-} from "./chunk-YZ5LQ32F.js";
+} from "./chunk-A6EG5WRL.js";
 import {
   HttpClientService,
   getHttpRequestPolicy,
   httpErrorStatus,
   isRetryableHttpError,
   makeDefaultHttpClient
-} from "./chunk-WUDHOZIH.js";
+} from "./chunk-RZGB3DXR.js";
 import {
   registerHttpEffect
 } from "./chunk-TRM4JUZQ.js";
 import {
   layerEffect,
   makeServiceTag
-} from "./chunk-S4HXADU4.js";
+} from "./chunk-EXBGIC66.js";
 import {
   Runtime,
   fromPromiseAbortable,
   getCurrentFiber
-} from "./chunk-TTSPIU3U.js";
+} from "./chunk-APQBU7TM.js";
 import {
   Cause,
   asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncSucceed,
   asyncSync
 } from "./chunk-UB4B6OFY.js";
 
@@ -134,43 +130,147 @@ function withHttpObservability(options) {
       return withLeanHttpSampledSpanObservability(next, resolved, metricCache);
     }
     return (req) => {
-      const run = asyncFlatMap(
-        beginHttpObservation(req, resolved, metricCache),
-        (state) => asyncFlatMap(
-          logHttpRequest(req, resolved),
-          () => asyncFlatMap(
-            prepareHttpRequest(req, resolved),
-            (wireReq) => asyncFold(
-              next(wireReq),
-              (error) => {
-                const finish = state.finishWithError(error);
-                const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
-                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? asyncSucceed(void 0) : spanEvent("http.client.error", {
-                  ...finish.spanAttributes,
-                  ...adaptiveLimiterAttrs,
-                  "error.type": error._tag
-                });
-                return asyncFlatMap(
-                  traceEvent,
-                  () => asyncFlatMap(logHttpError(req, error, finish, resolved), () => asyncFail(error))
-                );
-              },
-              (res) => {
-                const finish = state.finishWithResponse(res);
-                const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
-                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? asyncSucceed(void 0) : spanEvent("http.client.response", {
-                  ...finish.spanAttributes,
-                  ...adaptiveLimiterAttrs
-                });
-                return asyncFlatMap(
-                  traceEvent,
-                  () => asyncFlatMap(logHttpResponse(req, res, finish, resolved), () => asyncSucceed(res))
-                );
-              }
-            )
-          )
-        )
-      );
+      const run = asyncEffect((env, cb) => {
+        const startedAt = resolved.clock();
+        const baseLabels = getCachedBaseLabels(req, resolved, metricCache);
+        const inFlight = resolved.metrics ? getCachedMetric(
+          metricCache,
+          metricCache.inFlightGauges,
+          metricCacheKey("brass_http_client_in_flight", baseLabels),
+          () => resolved.metrics.gauge("brass_http_client_in_flight", baseLabels)
+        ) : void 0;
+        inFlight?.increment();
+        let finished = false;
+        let cancelInner;
+        const completeFinish = (outcome, status, extra) => {
+          const durationMs = Math.max(0, resolved.clock() - startedAt);
+          const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
+          if (!finished) {
+            finished = true;
+            if (inFlight && inFlight.value() > 0) inFlight.decrement();
+            if (resolved.metrics) {
+              getCachedMetric(
+                metricCache,
+                metricCache.requestCounters,
+                metricCacheKey("brass_http_client_requests_total", labels),
+                () => resolved.metrics.counter("brass_http_client_requests_total", labels)
+              ).increment();
+              getCachedMetric(
+                metricCache,
+                metricCache.durationHistograms,
+                metricCacheKey("brass_http_client_duration_ms", labels),
+                () => resolved.metrics.histogram(
+                  "brass_http_client_duration_ms",
+                  [...resolved.durationBuckets ?? DEFAULT_DURATION_BUCKETS],
+                  labels
+                )
+              ).observe(
+                durationMs,
+                resolved.spans === false ? void 0 : currentTraceExemplar(durationMs, startedAt + durationMs)
+              );
+            }
+          }
+          return {
+            durationMs,
+            outcome,
+            labels,
+            spanAttributes: resolved.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
+              "http.duration_ms": durationMs,
+              "http.outcome": outcome,
+              ...status ? { "http.status_code": Number(status) } : {},
+              ...status ? { "http.response.status_code": Number(status) } : {},
+              ...extra
+            }
+          };
+        };
+        const fiber = getCurrentFiber();
+        fiber?.addFinalizer?.(() => {
+          completeFinish("abort", void 0, { "http.cancelled": true });
+        });
+        const reqLogLevel = resolved.logs === false ? false : resolved.logs.requestLevel ?? false;
+        if (reqLogLevel) {
+          const logEff = logEffect(reqLogLevel, "http.client.request", requestLogFields(req, resolved));
+          registerHttpEffect(logEff, env, () => void 0);
+        }
+        const wireReq = resolved.injectTraceHeaders ? injectCurrentTraceContext(req) : req;
+        const onSuccess = (res) => {
+          const finish = completeFinish(httpStatusOutcome(res.status), String(res.status), {});
+          const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+          if (shouldEmitHttpSpanEvents(resolved)) {
+            const ev = spanEvent("http.client.response", {
+              ...finish.spanAttributes,
+              ...adaptiveAttrs
+            });
+            registerHttpEffect(ev, env, () => void 0);
+          }
+          const respLevel = resolved.logs === false ? false : (resolved.logs.responseLevel ?? false) || (finish.outcome === "error" ? resolved.logs.errorLevel ?? "warn" : false);
+          if (respLevel) {
+            const logEff = logEffect(respLevel, "http.client.response", {
+              ...requestLogFields(req, resolved),
+              status: res.status,
+              statusText: res.statusText,
+              outcome: finish.outcome,
+              durationMs: finish.durationMs
+            });
+            registerHttpEffect(logEff, env, () => void 0);
+          }
+          cb({ _tag: "Success", value: res });
+        };
+        const onError = (error) => {
+          const status = httpErrorStatus(error);
+          const finish = completeFinish(
+            httpErrorOutcome(error),
+            status !== void 0 ? String(status) : void 0,
+            {
+              "error.type": error._tag,
+              "http.retryable": isRetryableHttpError(error)
+            }
+          );
+          const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+          if (shouldEmitHttpSpanEvents(resolved)) {
+            const ev = spanEvent("http.client.error", {
+              ...finish.spanAttributes,
+              ...adaptiveAttrs,
+              "error.type": error._tag
+            });
+            registerHttpEffect(ev, env, () => void 0);
+          }
+          const errLevel = resolved.logs === false ? false : resolved.logs.errorLevel ?? "error";
+          if (errLevel) {
+            const statusText = httpErrorStatusText(error);
+            const logEff = logEffect(errLevel, "http.client.error", {
+              ...requestLogFields(req, resolved),
+              outcome: finish.outcome,
+              durationMs: finish.durationMs,
+              ...status !== void 0 ? { status } : {},
+              ...statusText ? { statusText } : {},
+              retryable: isRetryableHttpError(error),
+              errorTag: error._tag,
+              message: httpErrorMessage(error)
+            });
+            registerHttpEffect(logEff, env, () => void 0);
+          }
+          cb({ _tag: "Failure", cause: Cause.fail(error) });
+        };
+        try {
+          cancelInner = registerHttpEffect(next(wireReq), env, (exit) => {
+            cancelInner = void 0;
+            if (exit._tag === "Success") onSuccess(exit.value);
+            else {
+              const failure = Cause.firstFailure(exit.cause);
+              if (failure._tag === "Some") onError(failure.value);
+              else cb(exit);
+            }
+          });
+        } catch (error) {
+          cb({ _tag: "Failure", cause: Cause.die(error) });
+        }
+        return () => {
+          const cancel = cancelInner;
+          cancelInner = void 0;
+          cancel?.();
+        };
+      });
       if (resolved.spans === false) return run;
       return withSpan(spanName(req, resolved.spans), run, spanStartAttributes(req, resolved));
     };
@@ -191,7 +291,7 @@ function canUseLeanHttpSampledSpanPath(options, adaptiveLimiter) {
 function withLeanHttpSampledSpanObservability(next, options, metricCache) {
   return (req) => asyncEffect((env, cb) => {
     const startedAt = options.clock();
-    const baseLabels = requestBaseLabels(req, options);
+    const baseLabels = getCachedBaseLabels(req, options, metricCache);
     const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
     const span = startLeanHttpSpan(req, options);
     let finished = false;
@@ -256,7 +356,7 @@ function withLeanHttpSampledSpanObservability(next, options, metricCache) {
 function withLeanHttpMetricsObservability(next, options, metricCache) {
   return (req) => asyncEffect((env, cb) => {
     const startedAt = options.clock();
-    const baseLabels = requestBaseLabels(req, options);
+    const baseLabels = getCachedBaseLabels(req, options, metricCache);
     const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
     let finished = false;
     let cancelInner;
@@ -486,9 +586,23 @@ function makeHttpMetricCache() {
     leanEntries: /* @__PURE__ */ new Map(),
     inFlightGauges: /* @__PURE__ */ new Map(),
     requestCounters: /* @__PURE__ */ new Map(),
-    durationHistograms: /* @__PURE__ */ new Map()
+    durationHistograms: /* @__PURE__ */ new Map(),
+    baseLabelsCache: /* @__PURE__ */ new Map()
   };
 }
+function getCachedBaseLabels(req, options, cache) {
+  if (cache.disabled) return requestBaseLabels(req, options);
+  const route = requestRoute(req, options);
+  const host = options.includeHostLabel ? requestHost(req) : void 0;
+  const policy = getHttpRequestPolicy(req);
+  const preset = typeof policy === "string" ? policy : policy?.preset;
+  const key = `${req.method}|${host ?? ""}|${route ?? ""}|${preset ?? ""}`;
+  const existing = cache.baseLabelsCache.get(key);
+  if (existing) return existing;
+  const fresh = requestBaseLabels(req, options);
+  cache.baseLabelsCache.set(key, fresh);
+  return fresh;
+}
 function attachMetricCache(metrics, cache) {
   if (!metrics) return;
   const existing = metricResetRegistry.get(metrics);
@@ -536,112 +650,6 @@ function metricCacheKey(name, labels) {
   }
   return key;
 }
-function beginHttpObservation(req, options, metricCache) {
-  return asyncSync(() => {
-    const startedAt = options.clock();
-    let finished = false;
-    const baseLabels = requestBaseLabels(req, options);
-    const inFlight = options.metrics ? getCachedMetric(
-      metricCache,
-      metricCache.inFlightGauges,
-      metricCacheKey("brass_http_client_in_flight", baseLabels),
-      () => options.metrics.gauge("brass_http_client_in_flight", baseLabels)
-    ) : void 0;
-    inFlight?.increment();
-    const finish = (outcome, status, extra = {}) => {
-      const durationMs = Math.max(0, options.clock() - startedAt);
-      const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
-      if (!finished) {
-        finished = true;
-        if (inFlight && inFlight.value() > 0) inFlight.decrement();
-        if (options.metrics) {
-          getCachedMetric(
-            metricCache,
-            metricCache.requestCounters,
-            metricCacheKey("brass_http_client_requests_total", labels),
-            () => options.metrics.counter("brass_http_client_requests_total", labels)
-          ).increment();
-          getCachedMetric(
-            metricCache,
-            metricCache.durationHistograms,
-            metricCacheKey("brass_http_client_duration_ms", labels),
-            () => options.metrics.histogram(
-              "brass_http_client_duration_ms",
-              [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS],
-              labels
-            )
-          ).observe(
-            durationMs,
-            options.spans === false ? void 0 : currentTraceExemplar(durationMs, startedAt + durationMs)
-          );
-        }
-      }
-      return {
-        durationMs,
-        outcome,
-        labels,
-        spanAttributes: options.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
-          "http.duration_ms": durationMs,
-          "http.outcome": outcome,
-          ...status ? { "http.status_code": Number(status) } : {},
-          ...status ? { "http.response.status_code": Number(status) } : {},
-          ...extra
-        }
-      };
-    };
-    const fiber = getCurrentFiber();
-    fiber?.addFinalizer?.(() => {
-      finish("abort", void 0, { "http.cancelled": true });
-    });
-    return {
-      finishWithResponse: (res) => finish(httpStatusOutcome(res.status), String(res.status)),
-      finishWithError: (error) => {
-        const status = httpErrorStatus(error);
-        return finish(httpErrorOutcome(error), status !== void 0 ? String(status) : void 0, {
-          "error.type": error._tag,
-          "http.retryable": isRetryableHttpError(error)
-        });
-      }
-    };
-  });
-}
-function prepareHttpRequest(req, options) {
-  if (!options.injectTraceHeaders) return asyncSucceed(req);
-  return asyncSync(() => injectCurrentTraceContext(req));
-}
-function logHttpRequest(req, options) {
-  const level = options.logs === false ? false : options.logs.requestLevel ?? false;
-  if (!level) return asyncSucceed(void 0);
-  return logEffect(level, "http.client.request", requestLogFields(req, options));
-}
-function logHttpResponse(req, res, finish, options) {
-  const configured = options.logs === false ? false : options.logs.responseLevel ?? false;
-  const level = configured || (finish.outcome === "error" ? options.logs !== false ? options.logs.errorLevel ?? "warn" : false : false);
-  if (!level) return asyncSucceed(void 0);
-  return logEffect(level, "http.client.response", {
-    ...requestLogFields(req, options),
-    status: res.status,
-    statusText: res.statusText,
-    outcome: finish.outcome,
-    durationMs: finish.durationMs
-  });
-}
-function logHttpError(req, error, finish, options) {
-  const level = options.logs === false ? false : options.logs.errorLevel ?? "error";
-  if (!level) return asyncSucceed(void 0);
-  const status = httpErrorStatus(error);
-  const statusText = httpErrorStatusText(error);
-  return logEffect(level, "http.client.error", {
-    ...requestLogFields(req, options),
-    outcome: finish.outcome,
-    durationMs: finish.durationMs,
-    ...status !== void 0 ? { status } : {},
-    ...statusText ? { statusText } : {},
-    retryable: isRetryableHttpError(error),
-    errorTag: error._tag,
-    message: httpErrorMessage(error)
-  });
-}
 function resolveHttpObservabilityOptions(options) {
   const maybeObservability = isObservabilityInstance(options) ? options : void 0;
   const raw = maybeObservability ? { metrics: maybeObservability.metrics } : options;

package/dist/{chunk-6V2AWT4R.mjs → chunk-KAPZHDO4.mjs}

@@ -1,6 +1,6 @@
 import {
   makeBoundedRingBuffer
-} from "./chunk-H626ZTDZ.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause
 } from "./chunk-36I3M4UC.mjs";

package/dist/{chunk-EEN5OTCR.mjs → chunk-KDXNWGPB.mjs}

@@ -3,7 +3,7 @@ import {
   liveClock,
   runtimeClockFromEnv,
   unsafeGetCurrentRuntime
-} from "./chunk-H626ZTDZ.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Async,
   Cause,

package/dist/{chunk-UUMKZJRJ.cjs → chunk-KPOL2YEO.cjs}

@@ -237,7 +237,14 @@ function arraySchema(item) {
 function objectSchema(shape, options = {}) {
   const unknownKeys = _nullishCoalesce(options.unknownKeys, () => ( "strip"));
   const shapeEntries = Object.entries(shape);
-  const knownKeys = unknownKeys === "strict" ? new Set(shapeEntries.map(([key]) => key)) : void 0;
+  const fieldKeys = new Array(shapeEntries.length);
+  const fieldSchemas = new Array(shapeEntries.length);
+  for (let i = 0; i < shapeEntries.length; i++) {
+    fieldKeys[i] = shapeEntries[i][0];
+    fieldSchemas[i] = shapeEntries[i][1];
+  }
+  const fieldCount = fieldKeys.length;
+  const knownKeys = unknownKeys === "strict" ? new Set(fieldKeys) : void 0;
   return makeSchema("object", false, (input, path) => {
     if (typeof input !== "object" || input === null || Array.isArray(input)) {
       return fail([makeSchemaIssue(path, _nullishCoalesce(options.name, () => ( "object")), input)]);
@@ -246,11 +253,13 @@ function objectSchema(shape, options = {}) {
     const out = unknownKeys === "passthrough" ? { ...source } : {};
     const childPath = path.length === 0 ? [] : [...path];
     let issues;
-    for (const [key, fieldSchema] of shapeEntries) {
+    for (let i = 0; i < fieldCount; i++) {
+      const key = fieldKeys[i];
+      const fieldSchema = fieldSchemas[i];
       childPath.push(key);
       if (!(key in source)) {
         if (!fieldSchema.isOptional) {
-          issues ??= [];
+          if (!issues) issues = [];
           issues.push(makeSchemaIssue(childPath, _nullishCoalesce(fieldSchema.name, () => ( fieldSchema.kind)), void 0, "Required field is missing"));
         }
         childPath.pop();
@@ -261,15 +270,18 @@ function objectSchema(shape, options = {}) {
       if (result.success) {
         out[key] = result.data;
       } else {
-        issues ??= [];
-        issues.push(...result.issues);
+        if (!issues) issues = [];
+        const resultIssues = result.issues;
+        for (let j = 0; j < resultIssues.length; j++) {
+          issues.push(resultIssues[j]);
+        }
       }
     }
     if (knownKeys) {
       for (const key of Object.keys(source)) {
         if (!knownKeys.has(key)) {
           childPath.push(key);
-          issues ??= [];
+          if (!issues) issues = [];
           issues.push(makeSchemaIssue(childPath, "known key", source[key], "Unknown key is not allowed"));
           childPath.pop();
         }

package/dist/{chunk-J6DUHITE.cjs → chunk-MA74OYCI.cjs}

@@ -4,7 +4,7 @@ var _chunkSA6HUJVIcjs = require('./chunk-SA6HUJVI.cjs');
 
 
 
-var _chunk2JHJ4YHScjs = require('./chunk-2JHJ4YHS.cjs');
+var _chunkZDZNV6NAcjs = require('./chunk-ZDZNV6NA.cjs');
 
 
 
@@ -1914,7 +1914,7 @@ var runLoop = (state, scope, runStartedAt) => {
     })
   );
 };
-var runAgent = (runtime, goal) => _chunk2JHJ4YHScjs.withScopeAsync.call(void 0, 
+var runAgent = (runtime, goal) => _chunkZDZNV6NAcjs.withScopeAsync.call(void 0, 
   runtime,
   (scope) => _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
     nowMillis(),
@@ -2219,14 +2219,14 @@ var parseRipgrep = (stdout) => stdout.split("\n").filter(Boolean).map((line) =>
   return { path, line: Number(lineNo), text: rest.join(":") };
 });
 var makeNodeFileSystem = (shell) => ({
-  readFile: (path) => _chunk2JHJ4YHScjs.fromPromiseAbortable.call(void 0, 
+  readFile: (path) => _chunkZDZNV6NAcjs.fromPromiseAbortable.call(void 0, 
     async (signal) => {
       const { readFile } = await dynamicImport2("node:fs/promises");
       return readFile(path, { encoding: "utf8", signal });
     },
     (cause) => ({ _tag: "FsError", operation: "readFile", cause })
   ),
-  exists: (path) => _chunk2JHJ4YHScjs.fromPromiseAbortable.call(void 0, 
+  exists: (path) => _chunkZDZNV6NAcjs.fromPromiseAbortable.call(void 0, 
     async (signal) => {
       if (signal.aborted) return false;
       const { stat } = await dynamicImport2("node:fs/promises");
@@ -2607,7 +2607,7 @@ var loadNodeAgentConfig = async (options) => {
 // src/agent/llm/openAICompatible.ts
 var extractText = (json) => _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_optionalChain([json, 'optionalAccess', _150 => _150.choices, 'optionalAccess', _151 => _151[0], 'optionalAccess', _152 => _152.message, 'optionalAccess', _153 => _153.content]), () => ( _optionalChain([json, 'optionalAccess', _154 => _154.output_text]))), () => ( _optionalChain([json, 'optionalAccess', _155 => _155.content, 'optionalAccess', _156 => _156[0], 'optionalAccess', _157 => _157.text]))), () => ( JSON.stringify(json)));
 var makeOpenAICompatibleLLM = (config) => ({
-  complete: (request) => _chunk2JHJ4YHScjs.fromPromiseAbortable.call(void 0, 
+  complete: (request) => _chunkZDZNV6NAcjs.fromPromiseAbortable.call(void 0, 
     async (signal) => {
       const res = await fetch(config.endpoint, {
         method: "POST",
@@ -2699,7 +2699,7 @@ var responseErrorMessage = async (res) => {
   }
 };
 var makeGoogleGenerativeAILLM = (config) => ({
-  complete: (request) => _chunk2JHJ4YHScjs.fromPromiseAbortable.call(void 0, 
+  complete: (request) => _chunkZDZNV6NAcjs.fromPromiseAbortable.call(void 0, 
     async (signal) => {
       const res = await fetch(makeGenerateContentEndpoint(config), {
         method: "POST",