brass-runtime 1.14.0 → 1.16.0

package/dist/chunk-XDZOO4L5.js

@@ -0,0 +1,354 @@
+import {
+  makeBoundedRingBuffer
+} from "./chunk-7LVI2GIN.js";
+
+// src/core/runtime/metrics.ts
+var DEFAULT_BOUNDARIES = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 5e3, 1e4];
+function makeMetrics() {
+  const counters = /* @__PURE__ */ new Map();
+  const gauges = /* @__PURE__ */ new Map();
+  const histograms = /* @__PURE__ */ new Map();
+  const key = (name, labels) => labels ? `${name}|${Object.entries(labels).sort().map(([k, v]) => `${k}=${v}`).join(",")}` : name;
+  const counter = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!counters.has(k)) counters.set(k, { labels, value: 0 });
+    const entry = counters.get(k);
+    return {
+      increment: (n = 1) => {
+        entry.value += Math.max(0, n);
+      },
+      value: () => entry.value
+    };
+  };
+  const gauge = (name, labels = {}) => {
+    const k = key(name, labels);
+    if (!gauges.has(k)) gauges.set(k, { labels, value: 0 });
+    const entry = gauges.get(k);
+    return {
+      set: (v) => {
+        entry.value = v;
+      },
+      increment: (n = 1) => {
+        entry.value += n;
+      },
+      decrement: (n = 1) => {
+        entry.value -= n;
+      },
+      value: () => entry.value
+    };
+  };
+  const histogram = (name, boundaries = DEFAULT_BOUNDARIES, labels = {}) => {
+    const k = key(name, labels);
+    if (!histograms.has(k)) {
+      const sorted = [...boundaries].sort((a, b) => a - b);
+      histograms.set(k, {
+        labels,
+        boundaries: sorted,
+        data: { boundaries: sorted, counts: new Array(sorted.length + 1).fill(0), sum: 0, count: 0, min: Infinity, max: -Infinity }
+      });
+    }
+    const entry = histograms.get(k);
+    return {
+      observe: (value, exemplar) => {
+        entry.data.sum += value;
+        entry.data.count++;
+        entry.data.min = Math.min(entry.data.min, value);
+        entry.data.max = Math.max(entry.data.max, value);
+        let placed = false;
+        let bucketIndex = entry.boundaries.length;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          if (value <= entry.boundaries[i]) {
+            entry.data.counts[i]++;
+            bucketIndex = i;
+            placed = true;
+            break;
+          }
+        }
+        if (!placed) entry.data.counts[entry.boundaries.length]++;
+        if (exemplar) {
+          const exemplars = entry.data.exemplars ?? new Array(entry.boundaries.length + 1).fill(void 0);
+          exemplars[bucketIndex] = {
+            ...exemplar,
+            value,
+            timestamp: exemplar.timestamp
+          };
+          entry.data.exemplars = exemplars;
+        }
+      },
+      buckets: () => ({ ...entry.data, counts: [...entry.data.counts], exemplars: entry.data.exemplars ? [...entry.data.exemplars] : void 0 }),
+      percentile: (p) => {
+        const target = Math.ceil(entry.data.count * (p / 100));
+        let cumulative = 0;
+        for (let i = 0; i < entry.boundaries.length; i++) {
+          cumulative += entry.data.counts[i];
+          if (cumulative >= target) return entry.boundaries[i];
+        }
+        return entry.data.max;
+      }
+    };
+  };
+  return {
+    counter,
+    gauge,
+    histogram,
+    snapshot: () => ({
+      counters: Array.from(counters.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      gauges: Array.from(gauges.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, value: v.value })),
+      histograms: Array.from(histograms.entries()).map(([k, v]) => ({ name: k.split("|")[0], labels: v.labels, buckets: v.data }))
+    }),
+    reset: () => {
+      counters.clear();
+      gauges.clear();
+      histograms.clear();
+    }
+  };
+}
+
+// src/core/runtime/events.ts
+function makeRuntimeEventRecord(ev, ctx, seq) {
+  const wallTs = Date.now();
+  const ts = typeof performance !== "undefined" ? performance.now() : wallTs;
+  return {
+    ...ctx,
+    contextFiberId: ctx.fiberId,
+    contextScopeId: ctx.scopeId,
+    ...ev,
+    seq,
+    wallTs,
+    ts
+  };
+}
+function runtimeEventRecordContext(record) {
+  return {
+    fiberId: record.contextFiberId ?? record.fiberId,
+    scopeId: record.contextScopeId ?? record.scopeId,
+    traceId: record.traceId,
+    spanId: record.spanId,
+    parentSpanId: record.parentSpanId,
+    traceState: record.traceState,
+    baggage: record.baggage,
+    sampled: record.sampled
+  };
+}
+
+// src/core/runtime/eventBus.ts
+function runtimeHooksToEventHandler(hooks) {
+  return (record) => {
+    hooks.emit(record, runtimeEventRecordContext(record));
+  };
+}
+var EventBus = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  seq = 1;
+  subs = [];
+  flushScheduled = false;
+  boundFlush = () => this.flush();
+  emit(ev, ctx) {
+    if (this.subs.length === 0) return;
+    const full = makeRuntimeEventRecord(ev, ctx, this.seq++);
+    for (const s of this.subs) {
+      const st = s.q.push(full);
+      if (st & 2 /* Dropped */) s.dropped++;
+    }
+    if (!this.flushScheduled) {
+      this.flushScheduled = true;
+      queueMicrotask(this.boundFlush);
+    }
+  }
+  subscribe(handler, perSubscriberCapacity = 2048) {
+    this.subs.push({
+      handler,
+      q: makeBoundedRingBuffer(perSubscriberCapacity, perSubscriberCapacity, this.options),
+      dropped: 0
+    });
+    return () => {
+      this.subs = this.subs.filter((s) => s.handler !== handler);
+    };
+  }
+  subscribeHooks(hooks, perSubscriberCapacity = 2048) {
+    return this.subscribe(runtimeHooksToEventHandler(hooks), perSubscriberCapacity);
+  }
+  flush(budget = 4096) {
+    this.flushScheduled = false;
+    for (const s of this.subs) {
+      let n = 0;
+      if (s.dropped > 0) {
+        const dropEv = makeRuntimeEventRecord(
+          {
+            type: "log",
+            level: "warn",
+            message: "eventbus.dropped",
+            fields: { dropped: s.dropped }
+          },
+          {},
+          0
+        );
+        try {
+          s.handler(dropEv);
+        } catch {
+        }
+        s.dropped = 0;
+      }
+      while (n++ < budget) {
+        const ev = s.q.shift();
+        if (!ev) break;
+        try {
+          s.handler(ev);
+        } catch {
+        }
+      }
+    }
+  }
+};
+
+// src/core/runtime/tracingSink.ts
+var InMemoryTracer = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  spans = /* @__PURE__ */ new Map();
+  // key: spanId
+  prunedFinishedSpans = 0;
+  emit(ev, ctx) {
+    if (ctx.sampled === false) return;
+    const wallTs = this.now();
+    const traceId = ctx.traceId ?? "no-trace";
+    const spanId = ctx.spanId;
+    if (ev.type === "fiber.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name ?? `fiber#${ev.fiberId}`,
+        startWallTs: wallTs,
+        attrs: this.attrs({ fiberId: ev.fiberId, parentFiberId: ev.parentFiberId, scopeId: ev.scopeId }),
+        links: [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "fiber.end") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (sp) {
+        sp.endWallTs = wallTs;
+        sp.events.push({ wallTs, name: "fiber.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error) }) });
+        this.pruneFinished();
+      }
+      return;
+    }
+    if (ev.type === "span.start") {
+      if (!spanId) return;
+      this.spans.set(spanId, {
+        traceId,
+        spanId,
+        parentSpanId: ctx.parentSpanId,
+        traceState: ctx.traceState,
+        name: ev.name,
+        startWallTs: wallTs,
+        attrs: this.attrs(ev.attributes ?? {}),
+        links: ev.links ?? [],
+        events: []
+      });
+      return;
+    }
+    if (ev.type === "span.event") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.name, attrs: this.attrs(ev.attributes ?? {}) });
+      return;
+    }
+    if (ev.type === "span.end") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (sp) {
+        sp.endWallTs = wallTs;
+        sp.events.push({ wallTs, name: "span.end", attrs: this.attrs({ status: ev.status, error: this.error(ev.error), ...ev.attributes ?? {} }) });
+        this.pruneFinished();
+      }
+      return;
+    }
+    if (ev.type === "fiber.suspend" || ev.type === "fiber.resume" || ev.type === "scope.open" || ev.type === "scope.close") {
+      if (!spanId) return;
+      const sp = this.spans.get(spanId);
+      if (!sp) return;
+      sp.events.push({ wallTs, name: ev.type, attrs: this.attrs(ev) });
+    }
+  }
+  exportFinished() {
+    this.pruneFinished();
+    return Array.from(this.spans.values()).filter((s) => s.endWallTs != null);
+  }
+  pruneFinished(spanIds) {
+    let dropped = 0;
+    if (spanIds) {
+      for (const spanId of spanIds) {
+        const span = this.spans.get(spanId);
+        if (span?.endWallTs == null) continue;
+        if (this.spans.delete(spanId)) dropped++;
+      }
+      this.prunedFinishedSpans += dropped;
+      return dropped;
+    }
+    dropped += this.pruneExpiredFinished();
+    dropped += this.pruneFinishedOverLimit();
+    this.prunedFinishedSpans += dropped;
+    return dropped;
+  }
+  stats() {
+    return {
+      storedSpans: this.spans.size,
+      finishedSpans: Array.from(this.spans.values()).filter((s) => s.endWallTs != null).length,
+      prunedFinishedSpans: this.prunedFinishedSpans
+    };
+  }
+  attrs(attrs) {
+    return this.options.sanitizeAttributes?.(attrs) ?? attrs;
+  }
+  error(error) {
+    return error === void 0 ? void 0 : this.options.sanitizeError?.(error) ?? error;
+  }
+  now() {
+    return this.options.clock?.() ?? Date.now();
+  }
+  pruneExpiredFinished() {
+    const maxAgeMs = this.options.maxSpanAgeMs;
+    if (maxAgeMs === void 0 || maxAgeMs <= 0) return 0;
+    const now = this.now();
+    let dropped = 0;
+    for (const [spanId, span] of this.spans) {
+      if (span.endWallTs == null) continue;
+      if (now - span.endWallTs > maxAgeMs && this.spans.delete(spanId)) dropped++;
+    }
+    return dropped;
+  }
+  pruneFinishedOverLimit() {
+    const maxFinishedSpans = this.options.maxFinishedSpans;
+    if (maxFinishedSpans === void 0 || maxFinishedSpans < 0) return 0;
+    const finished = Array.from(this.spans.values()).filter((span) => span.endWallTs != null).sort((a, b) => (a.endWallTs ?? 0) - (b.endWallTs ?? 0));
+    const overflow = finished.length - maxFinishedSpans;
+    if (overflow <= 0) return 0;
+    let dropped = 0;
+    for (let i = 0; i < overflow; i++) {
+      const span = finished[i];
+      if (this.spans.delete(span.spanId)) dropped++;
+    }
+    return dropped;
+  }
+};
+
+export {
+  makeMetrics,
+  makeRuntimeEventRecord,
+  runtimeEventRecordContext,
+  runtimeHooksToEventHandler,
+  EventBus,
+  InMemoryTracer
+};

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/{chunk-MQF7HZ7Y.mjs → chunk-ZGLD4TVZ.mjs}

@@ -1,17 +1,23 @@
+import {
+  race
+} from "./chunk-J3H54ZRV.mjs";
+import {
+  withScopeAsync
+} from "./chunk-CCKHV5BT.mjs";
+import {
+  fromPromiseAbortable
+} from "./chunk-G6IQOE4P.mjs";
 import {
   Cause,
   Exit,
-  async,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
   asyncMap,
   asyncSucceed,
-  asyncSync,
-  fromPromiseAbortable,
-  race,
-  withScopeAsync
-} from "./chunk-4N2JEK4H.mjs";
+  asyncSync
+} from "./chunk-NOYZIMUJ.mjs";
 
 // src/agent/core/state.ts
 var initialAgentState = (goal) => ({
@@ -1425,10 +1431,10 @@ var decideNextAction = (state) => {
 };
 
 // src/agent/core/events.ts
-var nowMillis = () => async((_env, cb) => {
+var nowMillis = () => asyncEffect((_env, cb) => {
   cb({ _tag: "Success", value: Date.now() });
 });
-var emitAgentEvent = (event) => async((env, cb) => {
+var emitAgentEvent = (event) => asyncEffect((env, cb) => {
   try {
     env.events?.emit(event);
   } catch {
@@ -1684,7 +1690,7 @@ var retry = (make, options) => {
 };
 
 // src/agent/tools/timeout.ts
-var sleep = (ms) => async((_env, cb) => {
+var sleep = (ms) => asyncEffect((_env, cb) => {
   const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
   return () => clearTimeout(id);
 });
@@ -2124,7 +2130,7 @@ var chunkToString = (chunk) => {
   return typeof maybeToString === "function" ? maybeToString.call(chunk, "utf8") : String(chunk);
 };
 var NodeShell = {
-  exec: (command, options) => async((_env, cb) => {
+  exec: (command, options) => asyncEffect((_env, cb) => {
     const [bin, ...args] = command;
     if (!bin) {
       cb(