@byok-sdk/client 0.4.1 → 0.5.0

package/dist/daemon/create-daemon.d.ts

@@ -11,7 +11,7 @@ import { type LocalTaskJournal } from './journal/journal';
 import { type JournalOpenFaultSeam } from './journal/sqlite-support';
 import { LocalStoragePressureEngine, type LocalStoragePolicyInput } from './journal/storage-policy';
 import { type ResultDocumentExtractor } from './task-runner';
-import type { ProgressBatcherOptions } from './progress-batcher';
+import { type ProgressBatcherOptions } from './progress-batcher';
 /**
  * Optional white-label product display info — purely opaque passthrough
  * (never interpreted, validated, or rendered by the daemon itself). Carried
@@ -223,6 +223,14 @@ export interface DaemonConfig {
      * explicitly instead to opt out of enforcement altogether.
      */
     maxTaskOutputBytes?: number;
+    /**
+     * Host-owned batching policy for normalized `task.progress` events.
+     * `maxBatchBytes`, when set, measures exactly the UTF-8 bytes of
+     * `JSON.stringify(events)` and must match the deployment's activity-ingress
+     * budget. It is deliberately unset by default because that ingress ceiling
+     * is deployment policy, not a frozen protocol constant.
+     */
+    progressBatch?: ProgressBatcherOptions;
     /**
      * additive-minor (`task.complete.document`): the seam through which this
      * product turns a finished task's final output text into the STRUCTURED
@@ -415,7 +423,6 @@ export interface Daemon {
 /** Internal seam so tests can substitute stub adapters / faster backoff+batch+liveness+long-poll timing. `createDaemonWithAdapters` (which takes this) is also the real entry point for products supplying a hand-built adapter set `createDaemon` can't construct on its own — e.g. custom adapter options, or an adapter that REPLACES a bundled runtime's implementation under the same id. Honest limit: an adapter id outside `pi`/`claude`/`codex` cannot pass wire validation today — `RuntimeIdSchema` (`@byok-sdk/protocol`) is a closed `z.enum(['pi', 'claude', 'codex'])`, and `isRuntimeId` filtering below (see `detectRuntimes`) drops any detected adapter outside that set before it ever reaches a wire-visible field. A genuinely fourth/namespaced runtime id is a future protocol change, not something this seam enables today. */
 export interface DaemonOverrides {
     backoff?: BackoffOptions;
-    batch?: ProgressBatcherOptions;
     liveness?: LivenessOptions;
     /** M4 Phase 3: overrides `TaskRunner`'s default out-of-band approval wait (`DEFAULT_APPROVAL_TIMEOUT_MS`, 10 minutes) before an unanswered `requestApproval` force-resolves as a fail-closed rejection. */
     approvalTimeoutMs?: number;

package/dist/daemon/progress-batcher.d.ts

@@ -5,7 +5,19 @@ export interface ProgressBatcherOptions {
     maxBatchSize?: number;
     /** Otherwise flush at most this often (ms) while events are pending. Default 250 (~4/sec). */
     flushIntervalMs?: number;
+    /**
+     * Optional deployment-owned ceiling for the UTF-8 bytes in the serialized
+     * `events[]` array. Unset means no byte ceiling; hosts should inject the
+     * same value their activity ingress enforces.
+     */
+    maxBatchBytes?: number;
 }
+export declare class ProgressEventTooLargeError extends Error {
+    readonly actualBytes: number;
+    readonly maxBatchBytes: number;
+    constructor(actualBytes: number, maxBatchBytes: number);
+}
+export declare function validateProgressBatcherOptions(options?: ProgressBatcherOptions): void;
 /**
  * Coalesces a task's `AgentEvent`s into seq-ordered `task.progress` batches:
  * flush immediately at `maxBatchSize` events, otherwise at most every
@@ -19,6 +31,7 @@ export declare class ProgressBatcher {
     private timer;
     private readonly maxBatchSize;
     private readonly flushIntervalMs;
+    private readonly maxBatchBytes;
     constructor(emit: ProgressEmitter, options?: ProgressBatcherOptions);
     push(event: AgentEvent): void;
     /** M4 Phase 4 (part B.3, observability): events buffered right now, not yet flushed as a `task.progress` batch — a cheap per-task queue-depth watermark for the daemon's control-socket `status` result (see `task-runner.ts`'s `getQueueWatermarks`). */

package/dist/daemon/task-runner.d.ts

@@ -102,6 +102,8 @@ export declare const MAX_TRACKED_TASK_IDS = 2000;
 export declare const MAX_DURATION_EXCEEDED_REASON_PREFIX = "resource limit exceeded: maxDurationMs";
 /** M5 batch-3 (workstream 2): same contract as {@link MAX_DURATION_EXCEEDED_REASON_PREFIX}, for `DaemonConfig.maxTaskOutputBytes` — see `TaskRunner.pump`'s own per-event byte counting. */
 export declare const MAX_OUTPUT_BYTES_EXCEEDED_REASON_PREFIX = "resource limit exceeded: maxTaskOutputBytes";
+/** Stable fail-closed reason for one normalized event that cannot fit the configured activity batch budget. */
+export declare const MAX_PROGRESS_BATCH_BYTES_EXCEEDED_REASON_PREFIX = "resource limit exceeded: progressBatch.maxBatchBytes";
 /**
  * additive-minor (`task.complete.document`): same stable-PREFIX contract as
  * {@link MAX_DURATION_EXCEEDED_REASON_PREFIX} above, carried by every

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { GitWorkspaceStore } from './daemon/git-workspace-store';
 export type { GitWorkspaceLedger, GitWorkspaceLedgerRecord, GitWorkspacePhase } from './daemon/git-workspace-store';
 export { createDaemon, createDaemonWithAdapters } from './daemon/create-daemon';
 export type { Daemon, DaemonConfig, DaemonStatus, DaemonOverrides, DaemonBranding, HostedJournalConfig, DeviceAssertionConfig } from './daemon/create-daemon';
+export type { ProgressBatcherOptions } from './daemon/progress-batcher';
 /**
  * Plan `device-assertion-broker`: the ONLY control-socket capability this
  * package exposes publicly. `connectControlClient`/`ControlClient` are

package/dist/index.js

@@ -878,6 +878,24 @@ function mapPermissionPolicyToPiArgs(policy) {
 }
 
 // src/adapters/pi/events.ts
+function requireToolCallId(msg) {
+  if (typeof msg.toolCallId === "string" && msg.toolCallId.trim().length > 0) return msg.toolCallId;
+  throw new RuntimeExecutionFailure({
+    phase: "run",
+    category: "authority",
+    retry: "non-retryable",
+    reason: `pi ${msg.type} frame had no authoritative tool call id`
+  });
+}
+function requireToolResultOutcome(msg) {
+  if (typeof msg.isError === "boolean") return msg.isError;
+  throw new RuntimeExecutionFailure({
+    phase: "run",
+    category: "authority",
+    retry: "non-retryable",
+    reason: "pi tool_execution_end frame had no authoritative isError outcome"
+  });
+}
 function mapPiMessageToAgentEvent(msg) {
   switch (msg.type) {
     case "message_update": {
@@ -888,16 +906,22 @@ function mapPiMessageToAgentEvent(msg) {
       return void 0;
     }
     case "tool_execution_start": {
+      const toolCallId = requireToolCallId(msg);
       if (typeof msg.toolName !== "string") return void 0;
-      return { type: "tool_use", tool: msg.toolName, input: msg.args };
+      return { type: "tool_use", tool: msg.toolName, input: msg.args, toolCallId };
     }
     case "tool_execution_end": {
+      const toolCallId = requireToolCallId(msg);
+      const isError = requireToolResultOutcome(msg);
       if (typeof msg.toolName !== "string") return void 0;
-      return {
+      const event = {
         type: "tool_result",
         tool: msg.toolName,
-        output: { result: msg.result, isError: msg.isError === true }
+        output: { result: msg.result },
+        toolCallId,
+        isError
       };
+      return event;
     }
     case "agent_settled":
       return { type: "turn_end" };
@@ -1909,6 +1933,17 @@ function subtractDenied(tools, denyTools) {
 function createToolUseCorrelation() {
   return { toolNameByUseId: /* @__PURE__ */ new Map() };
 }
+function missingToolCallIdFailure(frame) {
+  return new RuntimeExecutionFailure({
+    phase: "run",
+    category: "authority",
+    retry: "non-retryable",
+    reason: `claude ${frame} frame had no authoritative tool call id`
+  });
+}
+function isAuthoritativeToolCallId(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
 var ROUTINE_CLAUDE_SYSTEM_SUBTYPES = /* @__PURE__ */ new Set([
   "init",
   "hook_started",
@@ -1952,9 +1987,12 @@ function mapAssistant(msg, correlation) {
         }
         break;
       case "tool_use":
-        if (typeof block.id === "string" && typeof block.name === "string") {
+        if (!isAuthoritativeToolCallId(block.id)) {
+          return { events: [], terminalFailure: missingToolCallIdFailure("tool_use") };
+        }
+        if (typeof block.name === "string") {
           correlation.toolNameByUseId.set(block.id, block.name);
-          events.push({ type: "tool_use", tool: block.name, input: block.input });
+          events.push({ type: "tool_use", tool: block.name, input: block.input, toolCallId: block.id });
         }
         break;
       // Deliberately NOT mapped to `progress` — mirrors pi's own choice to
@@ -1990,11 +2028,20 @@ function mapUser(msg, correlation, options) {
       unmappedLabel = unmappedLabel ?? `user-block:${String(block.type)}`;
       continue;
     }
-    const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : void 0;
-    const tool = toolUseId && correlation.toolNameByUseId.get(toolUseId) || "unknown";
-    const isError = block.is_error === true;
-    events.push({ type: "tool_result", tool, output: { content: block.content, isError } });
-    if (!isError && FILE_WRITING_TOOLS.has(tool)) {
+    if (!isAuthoritativeToolCallId(block.tool_use_id)) {
+      return { events: [], terminalFailure: missingToolCallIdFailure("tool_result") };
+    }
+    const tool = correlation.toolNameByUseId.get(block.tool_use_id) ?? "unknown";
+    const isError = typeof block.is_error === "boolean" ? block.is_error : void 0;
+    const event = {
+      type: "tool_result",
+      tool,
+      output: { content: block.content },
+      toolCallId: block.tool_use_id
+    };
+    if (isError !== void 0) event.isError = isError;
+    events.push(event);
+    if (isError === false && FILE_WRITING_TOOLS.has(tool)) {
       const artifact = tryBuildArtifactEvent(msg, options.workspaceDir);
       if (artifact) events.push(artifact);
     }
@@ -2617,8 +2664,8 @@ var ClaudeSession = class {
             for (; ; ) {
               const buffered = pending.shift();
               if (buffered) return { value: buffered, done: false };
+              if (terminalFailure) throw terminalFailure;
               if (turnSettled) {
-                if (terminalFailure) throw terminalFailure;
                 return { value: void 0, done: true };
               }
               let raw;
@@ -2820,6 +2867,15 @@ function extractCodexUsageEvent(rawUsage) {
 function toNonNegativeInt2(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
 }
+function requireToolCallId2(item) {
+  if (typeof item.id === "string" && item.id.trim().length > 0) return item.id;
+  throw new RuntimeExecutionFailure({
+    phase: "run",
+    category: "authority",
+    retry: "non-retryable",
+    reason: "codex tool item had no authoritative tool call id"
+  });
+}
 function mapItem(rawItem, phase, workspaceDir) {
   if (!rawItem || typeof rawItem !== "object") return [];
   const item = rawItem;
@@ -2830,9 +2886,10 @@ function mapItem(rawItem, phase, workspaceDir) {
       return typeof item.text === "string" ? [{ type: "progress", text: item.text }] : [];
     }
     case "command_execution": {
+      const toolCallId = requireToolCallId2(item);
       const command = typeof item.command === "string" ? item.command : void 0;
       if (phase === "started") {
-        return command !== void 0 ? [{ type: "tool_use", tool: "command_execution", input: { command } }] : [];
+        return command !== void 0 ? [{ type: "tool_use", tool: "command_execution", input: { command }, toolCallId }] : [];
       }
       return [
         {
@@ -2843,17 +2900,19 @@ function mapItem(rawItem, phase, workspaceDir) {
             aggregatedOutput: item.aggregated_output,
             exitCode: item.exit_code,
             status: item.status
-          }
+          },
+          toolCallId
         }
       ];
     }
     case "file_change": {
+      const toolCallId = requireToolCallId2(item);
       const changes = Array.isArray(item.changes) ? item.changes : [];
       if (phase === "started") {
-        return [{ type: "tool_use", tool: "file_change", input: { changes } }];
+        return [{ type: "tool_use", tool: "file_change", input: { changes }, toolCallId }];
       }
       return [
-        { type: "tool_result", tool: "file_change", output: { changes, status: item.status } },
+        { type: "tool_result", tool: "file_change", output: { changes, status: item.status }, toolCallId },
         ...extractArtifactEvents(changes, workspaceDir)
       ];
     }
@@ -3276,7 +3335,15 @@ async function runCodexTurn(params) {
           }
           return;
         }
-        const mapped = mapCodexEventToAgentEvents(evt, params.workspaceDir);
+        let mapped;
+        try {
+          mapped = mapCodexEventToAgentEvents(evt, params.workspaceDir);
+        } catch (cause) {
+          if (!isRuntimeExecutionFailure(cause)) throw cause;
+          params.terminal.failure = cause;
+          params.queue.end();
+          return;
+        }
         for (const agentEvent of mapped) {
           if (agentEvent.type === "turn_end") turnEnded = true;
           params.queue.push(agentEvent);
@@ -8121,6 +8188,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",
@@ -8228,11 +8300,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 = [];
@@ -8240,7 +8338,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();
@@ -8293,6 +8401,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) {
@@ -9149,6 +9258,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);
@@ -10235,6 +10351,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,
@@ -10520,7 +10637,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,