@byok-sdk/client 0.4.2 → 0.5.0

package/README.md

@@ -63,6 +63,24 @@ validated registry. Only those logical IDs are advertised in `conn.hello`
 and hosted presence; command, args, environment, headers, and credentials
 remain local.
 
+Hosted deployments that enforce an activity-ingress byte ceiling should inject
+the same ceiling into the daemon. The byte count is the UTF-8 length of
+`JSON.stringify(events)`; it does not include envelope or transport overhead.
+One event that cannot fit fails the task locally without truncation or network
+delivery.
+
+```ts
+createDaemon({
+  // ...normal device and transport configuration
+  progressBatch: {
+    maxBatchBytes: 64 * 1024,
+  },
+});
+```
+
+The value is intentionally host-owned and has no SDK default because it is a
+deployment/read-model policy, not a frozen protocol limit.
+
 For a concrete private host composition, see the
 [`examples/salesko-connector-broker`](../../examples/salesko-connector-broker)
 reference. It keeps `@byok-sdk/client` credential-blind while combining

package/dist/bin/byok-agent.js

@@ -8275,6 +8275,11 @@ function createStatfsFreeBytesProvider(dir) {
 var BASE_PLATFORM_ALLOWLIST = [
   "PATH",
   "HOME",
+  // macOS credential-store discovery used by subscription-authenticated
+  // agent CLIs depends on the login account name as well as HOME. Omitting
+  // USER makes `claude auth status` report logged out under the filtered
+  // child environment even when the host CLI is logged in.
+  "USER",
   "USERPROFILE",
   "TMPDIR",
   "TEMP",
@@ -8382,11 +8387,37 @@ function computeEffectivePolicy(offered, ceiling) {
 }
 
 // src/daemon/progress-batcher.ts
+var ProgressEventTooLargeError = class extends Error {
+  constructor(actualBytes, maxBatchBytes) {
+    super(`Progress event requires ${actualBytes} UTF-8 bytes, exceeding maxBatchBytes ${maxBatchBytes}.`);
+    this.actualBytes = actualBytes;
+    this.maxBatchBytes = maxBatchBytes;
+    this.name = "ProgressEventTooLargeError";
+  }
+  actualBytes;
+  maxBatchBytes;
+};
+var encoder = new TextEncoder();
+function assertPositiveSafeInteger(value, name) {
+  if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new TypeError(`${name} must be a positive safe integer when configured.`);
+  }
+}
+function validateProgressBatcherOptions(options = {}) {
+  assertPositiveSafeInteger(options.maxBatchSize, "maxBatchSize");
+  assertPositiveSafeInteger(options.flushIntervalMs, "flushIntervalMs");
+  assertPositiveSafeInteger(options.maxBatchBytes, "maxBatchBytes");
+}
+function encodedEventsBytes(events) {
+  return encoder.encode(JSON.stringify(events)).length;
+}
 var ProgressBatcher = class {
   constructor(emit, options = {}) {
     this.emit = emit;
+    validateProgressBatcherOptions(options);
     this.maxBatchSize = options.maxBatchSize ?? 10;
     this.flushIntervalMs = options.flushIntervalMs ?? 250;
+    this.maxBatchBytes = options.maxBatchBytes;
   }
   emit;
   buffer = [];
@@ -8394,7 +8425,17 @@ var ProgressBatcher = class {
   timer;
   maxBatchSize;
   flushIntervalMs;
+  maxBatchBytes;
   push(event) {
+    if (this.maxBatchBytes !== void 0) {
+      const eventBytes = encodedEventsBytes([event]);
+      if (eventBytes > this.maxBatchBytes) {
+        throw new ProgressEventTooLargeError(eventBytes, this.maxBatchBytes);
+      }
+      if (this.buffer.length > 0 && encodedEventsBytes([...this.buffer, event]) > this.maxBatchBytes) {
+        this.flush();
+      }
+    }
     this.buffer.push(event);
     if (this.buffer.length >= this.maxBatchSize) {
       this.flush();
@@ -8447,6 +8488,7 @@ var MAX_INLINE_ARTIFACT_BYTES = 64 * 1024;
 var MAX_TRACKED_TASK_IDS = 2e3;
 var MAX_DURATION_EXCEEDED_REASON_PREFIX = "resource limit exceeded: maxDurationMs";
 var MAX_OUTPUT_BYTES_EXCEEDED_REASON_PREFIX = "resource limit exceeded: maxTaskOutputBytes";
+var MAX_PROGRESS_BATCH_BYTES_EXCEEDED_REASON_PREFIX = "resource limit exceeded: progressBatch.maxBatchBytes";
 var RESULT_DOCUMENT_UNDELIVERABLE_REASON_PREFIX = "result document undeliverable";
 function resultDocumentRejectionDetail(check) {
   switch (check.reason) {
@@ -9303,6 +9345,13 @@ var TaskRunner = class {
     } catch (err) {
       if (this.tasks.get(active.taskId) !== active || active.beingTornDown) return;
       active.batcher.flush();
+      if (err instanceof ProgressEventTooLargeError) {
+        await this.failActiveTaskForResourceLimit(
+          active.taskId,
+          `${MAX_PROGRESS_BATCH_BYTES_EXCEEDED_REASON_PREFIX}: event requires ${err.actualBytes} UTF-8 bytes, exceeding the configured limit of ${err.maxBatchBytes} bytes`
+        );
+        return;
+      }
       const failure = projectRuntimeBoundaryFailure(err, "run");
       if (failure.contractViolation) {
         console.error("[byok/client] runtime adapter events iterable returned an untyped failure", err);
@@ -10389,6 +10438,7 @@ function buildDaemonWithAdapters(config, adapters, overrides = {}, assertionProb
       `DaemonConfig.maxTaskOutputBytes must be a positive number (or omitted to use the ${DEFAULT_MAX_TASK_OUTPUT_BYTES}-byte default) \u2014 got ${config.maxTaskOutputBytes}. Pass Number.POSITIVE_INFINITY to explicitly disable the cap; 0 or a negative number is rejected rather than silently treated as "disabled".`
     );
   }
+  validateProgressBatcherOptions(config.progressBatch);
   const presenceCadence = {
     intervalMs: config.presence?.intervalMs ?? DEFAULT_PRESENCE_HEARTBEAT_INTERVAL_MS,
     ttlMs: config.presence?.ttlMs ?? DEFAULT_PRESENCE_TTL_MS,
@@ -10674,7 +10724,7 @@ function buildDaemonWithAdapters(config, adapters, overrides = {}, assertionProb
         // untouched. See `observer.ts`'s module doc comment.
         send: sendEnvelope,
         blobClient,
-        batcherOptions: overrides.batch,
+        batcherOptions: config.progressBatch,
         sessionWorkspaces,
         gitWorkspaceManager,
         gitWorkspaceStore,