0sec-cli 0.22.1 → 0.23.0

package/chunks/{chunk-XCISCI4T.js → chunk-QMICC5O2.js}

@@ -3,7 +3,10 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   jitterFor
-} from "./chunk-YL6YAGLL.js";
+} from "./chunk-JEYIWMGL.js";
+import {
+  scanExecutionSignal
+} from "./chunk-CP6HANBE.js";
 
 // packages/core/dist/scope/rate-limit.js
 var TokenBucket = class {
@@ -57,24 +60,26 @@ var TokenBucket = class {
    * the 429 park deadline first, then refill-and-spin with sleeps
    * sized to the exact next-token-available time.
    */
-  async acquire(n = 1) {
+  async acquire(n = 1, signal = scanExecutionSignal()) {
+    signal?.throwIfAborted();
     if (n > this.state.capacity) {
       n = this.state.capacity;
     }
     while (this.nowFn() < this.state.retryUntil) {
       const wait = this.state.retryUntil - this.nowFn();
-      await this.sleepFn(Math.max(1, Math.min(wait, 1e3)));
+      await this.sleepFn(Math.max(1, Math.min(wait, 1e3)), signal);
     }
     while (true) {
+      signal?.throwIfAborted();
       this.refill();
       if (this.state.tokens >= n) {
         this.state.tokens -= n;
-        await this.pace();
+        await this.pace(signal);
         return;
       }
       const tokensNeeded = n - this.state.tokens;
       const waitMs = Math.max(1, Math.ceil(tokensNeeded / this.state.refillRatePerMs));
-      await this.sleepFn(waitMs);
+      await this.sleepFn(waitMs, signal);
     }
   }
   /**
@@ -85,12 +90,13 @@ var TokenBucket = class {
    * yields full jitter in `[0, baseMs]` — rather than growing a second
    * jitter implementation.
    */
-  async pace() {
+  async pace(signal = scanExecutionSignal()) {
+    signal?.throwIfAborted();
     if (!this.jitter)
       return;
     const ms = jitterFor(0, this.jitter.baseMs, this.jitter.rng ?? Math.random);
     if (ms > 0)
-      await this.sleepFn(ms);
+      await this.sleepFn(ms, signal);
   }
   /**
    * Park the bucket until `deadline` (ms since epoch). Subsequent
@@ -187,17 +193,18 @@ var RateLimiter = class _RateLimiter {
    * immediately) — callers should not rely on rate-limiting unknowable
    * hosts. The fetch sites that wire this up always pass full URLs.
    */
-  async acquire(urlOrHost, n = 1) {
+  async acquire(urlOrHost, n = 1, signal = scanExecutionSignal()) {
+    signal?.throwIfAborted();
     const host = this.hostKey(urlOrHost);
     if (!host)
       return;
     const bucket = this.getBucket(host);
     if (bucket.tryConsume(n)) {
-      await bucket.pace();
+      await bucket.pace(signal);
       return;
     }
     this.onThrottle?.();
-    await bucket.acquire(n);
+    await bucket.acquire(n, signal);
   }
   /**
    * Non-blocking variant. Returns true and consumes if available,
@@ -238,8 +245,19 @@ var RateLimiter = class _RateLimiter {
     this.buckets.clear();
   }
 };
-function defaultSleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
+function defaultSleep(ms, signal) {
+  signal?.throwIfAborted();
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", abort);
+    resolve();
+  }, ms);
+  const abort = () => {
+    clearTimeout(timer);
+    reject(signal?.reason ?? new Error("Rate-limit wait cancelled."));
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  return promise;
 }
 function readHeader(headers, name) {
   if (typeof headers.get === "function") {

package/chunks/{chunk-6GHSR47F.js → chunk-R35KKJA4.js}

@@ -5,54 +5,7 @@ import {
   expandHomePath,
   isExistingLocalTargetPath,
   isExplicitLocalTargetPath
-} from "./chunk-V36HVTUL.js";
-
-// packages/cli/src/herdr-state.ts
-var sink = null;
-function setHerdrSink(next) {
-  sink = next;
-}
-function reportOperatorGate(blocked) {
-  if (!sink) return;
-  try {
-    if (blocked) sink.reportBlocked();
-    else sink.reportWorking();
-  } catch {
-  }
-}
-function withSink(fn) {
-  if (!sink) return;
-  try {
-    fn(sink);
-  } catch {
-  }
-}
-function reportHerdrModel(model, provider) {
-  withSink((s) => s.setModel(model, provider));
-}
-function reportHerdrContextPercent(percent) {
-  withSink((s) => s.setContextPercent(percent));
-}
-function reportHerdrTarget(target) {
-  withSink((s) => s.setTarget(target));
-}
-function reportHerdrObjective(objective) {
-  withSink((s) => s.setObjective(objective));
-}
-function reportHerdrActivity(activity) {
-  withSink((s) => s.setActivity(activity));
-}
-function reportHerdrCompaction() {
-  withSink((s) => s.reportCompacting());
-}
-function reportHerdrSession(ref) {
-  withSink((s) => s.reportSession(ref));
-}
-function reportHerdrSessionClose() {
-  withSink((s) => {
-    void s.release();
-  });
-}
+} from "./chunk-YAEJAZYW.js";
 
 // packages/cli/src/engagement-plan.ts
 var PACKAGE_PREFIXES = {
@@ -133,15 +86,5 @@ function resolveEngagement(rawTarget) {
 }
 
 export {
-  setHerdrSink,
-  reportOperatorGate,
-  reportHerdrModel,
-  reportHerdrContextPercent,
-  reportHerdrTarget,
-  reportHerdrObjective,
-  reportHerdrActivity,
-  reportHerdrCompaction,
-  reportHerdrSession,
-  reportHerdrSessionClose,
   resolveEngagement
 };

package/chunks/chunk-RS4MAN3Q.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
+
+// packages/core/dist/runtime/prompt-cache.js
+var MAX_CACHE_BREAKPOINTS = 4;
+var MESSAGE_CACHE_BREAKPOINTS = MAX_CACHE_BREAKPOINTS - 1;
+var BREAKPOINT_SPACING_BLOCKS = 15;
+var NATIVE_CACHE_PROVIDERS = /* @__PURE__ */ new Set(["anthropic"]);
+var OPT_IN_CACHE_PROVIDERS = /* @__PURE__ */ new Set(["z-ai", "kimi"]);
+function providerSupportsPromptCache(provider) {
+  if (NATIVE_CACHE_PROVIDERS.has(provider))
+    return true;
+  if (!OPT_IN_CACHE_PROVIDERS.has(provider))
+    return false;
+  return readExtraCacheProviders().has(provider);
+}
+function readExtraCacheProviders() {
+  const raw = process.env["ZERO_PROMPT_CACHE_EXTRA_PROVIDERS"];
+  if (!raw)
+    return /* @__PURE__ */ new Set();
+  return new Set(raw.split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0));
+}
+function planMessageBreakpoints(messages, budget = MESSAGE_CACHE_BREAKPOINTS) {
+  if (messages.length === 0 || budget <= 0)
+    return [];
+  const lastIndex = messages.length - 1;
+  const picks = /* @__PURE__ */ new Set([lastIndex]);
+  const rollingBudget = Math.max(1, budget - 1);
+  let blocksSincePick = blockCount(messages[lastIndex]);
+  for (let i = lastIndex - 1; i >= 0 && picks.size < rollingBudget; i--) {
+    if (blocksSincePick >= BREAKPOINT_SPACING_BLOCKS) {
+      picks.add(i);
+      blocksSincePick = 0;
+    }
+    blocksSincePick += blockCount(messages[i]);
+  }
+  if (picks.size < budget)
+    picks.add(0);
+  return [...picks].sort((a, b) => a - b).slice(0, budget);
+}
+function blockCount(message) {
+  return message?.content.length ?? 0;
+}
+function withCacheControl(block) {
+  return { ...block, cache_control: { type: "ephemeral" } };
+}
+function readCacheUsage(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return void 0;
+  const usage = raw;
+  const uncachedInput = numberOr(usage.input_tokens, 0);
+  const outputTokens = numberOr(usage.output_tokens, 0);
+  const cacheRead = numberOr(usage.cache_read_input_tokens, void 0);
+  const cacheWrite = numberOr(usage.cache_creation_input_tokens, void 0);
+  return {
+    inputTokens: uncachedInput + (cacheRead ?? 0) + (cacheWrite ?? 0),
+    outputTokens,
+    ...cacheRead !== void 0 ? { cachedInputTokens: cacheRead } : {},
+    ...cacheWrite !== void 0 ? { cacheWriteTokens: cacheWrite } : {}
+  };
+}
+function numberOr(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export {
+  MESSAGE_CACHE_BREAKPOINTS,
+  providerSupportsPromptCache,
+  planMessageBreakpoints,
+  withCacheControl,
+  readCacheUsage
+};