frizz-server 0.15.24 → 0.15.26

package/dist/claude-agent-broker.js

@@ -26181,15 +26181,16 @@ var RESERVED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "protot
 var DELIVERABLE_CONTROL_CODES = /* @__PURE__ */ new Set([9, 10, 13]);
 function hasUndeliverableInputText(value) {
   for (const character of value) {
-    const code = character.codePointAt(0);
-    if (code >= 55296 && code <= 57343) return true;
-    if (code === 8232 || code === 8233) return true;
-    if (code <= 31 || code >= 127 && code <= 159) {
-      if (!DELIVERABLE_CONTROL_CODES.has(code)) return true;
-    }
+    if (isUndeliverableInputCode(character.codePointAt(0))) return true;
   }
   return false;
 }
+function isUndeliverableInputCode(code) {
+  if (code >= 55296 && code <= 57343) return true;
+  if (code === 8232 || code === 8233) return true;
+  if (code <= 31 || code >= 127 && code <= 159) return !DELIVERABLE_CONTROL_CODES.has(code);
+  return false;
+}
 var CLAUDE_BROKER_CAPABILITY_SUBAGENT_STEER = "subagent-steer-v1";
 var CLAUDE_BROKER_CAPABILITY_CANCEL_INPUT = "cancel-input-v1";
 var CLAUDE_BROKER_CAPABILITY_STOP_TASK = "stop-task-v1";
@@ -26197,6 +26198,7 @@ var CLAUDE_BROKER_CAPABILITY_RELOAD_PLUGINS = "reload-plugins-v1";
 var CLAUDE_BROKER_CAPABILITY_RENAME = "rename-v1";
 var CLAUDE_BROKER_CAPABILITY_LIST_SKILLS = "list-skills-v1";
 var CLAUDE_BROKER_CAPABILITY_INPUT_ACK = "input-ack-v1";
+var CLAUDE_SEND_NOW_OUTCOMES = ["stopped", "delivering", "nothing_waiting"];
 var CLAUDE_INPUT_DROP_DIAGNOSTIC_PREFIX = "input dropped, the agent never received it";
 var ClaudeAgentSdkProtocolError = class extends Error {
   constructor(message) {
@@ -26291,7 +26293,8 @@ function validateInputMessage(value) {
   const text = value.text;
   if (hasUndeliverableInputText(text)) throw new ClaudeAgentSdkProtocolError("input.text contains unsafe text");
   const parentToolUseId = boundedOptionalId(value.parentToolUseId, "input.parentToolUseId");
-  return parentToolUseId === void 0 ? { id: id2, text } : { id: id2, text, parentToolUseId };
+  const human = value.human === true ? { human: true } : {};
+  return parentToolUseId === void 0 ? { id: id2, text, ...human } : { id: id2, text, parentToolUseId, ...human };
 }
 function validatePermissionMode(value) {
   if (typeof value === "string" && ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"].includes(value)) {
@@ -26442,6 +26445,11 @@ function redactCredentialSyntax(raw, options = {}) {
 var CLAUDE_AGENT_SDK_CLIENT_APP = "frizz/claude-agent-sdk-foundation";
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var CLAUDE_SDK_CANCEL_METHOD = "cancelAsyncMessage";
+var CLAUDE_CLI_CAPABILITY_SEND_NOW = "interrupt_send_now_v1";
+var CLAUDE_SDK_REQUEST_METHOD = "request";
+function stillQueuedIds(raw) {
+  return boundedStringArray(raw, "interrupt.stillQueued", 256, 512).map((id2, index) => boundedId(id2, `interrupt.stillQueued[${index}]`));
+}
 var ENV_KEY_PATTERN = /^[^=\0]+$/;
 var SENSITIVE_ENV_KEY = /(?:API_KEY|AUTH|BASE_URL|BEARER|COOKIE|CREDENTIAL|OAUTH|PASSWORD|PRIVATE|SECRET|TOKEN)/i;
 var MAX_ENV_ENTRIES = 512;
@@ -26467,6 +26475,7 @@ function createClaudeQueryFactory(options) {
 var BoundedAsyncQueue = class {
   buffered = [];
   waiters = [];
+  drainListeners = [];
   ended = false;
   failure;
   limit;
@@ -26489,19 +26498,36 @@ var BoundedAsyncQueue = class {
     if (this.ended || this.failure) return;
     this.ended = true;
     for (const waiter of this.waiters.splice(0)) waiter.resolve({ done: true, value: void 0 });
+    for (const settle of this.drainListeners.splice(0)) settle();
   }
   fail(error) {
     if (this.ended || this.failure) return;
     this.failure = error;
     this.buffered.splice(0);
     for (const waiter of this.waiters.splice(0)) waiter.reject(error);
+    for (const settle of this.drainListeners.splice(0)) settle();
   }
   next() {
     const value = this.buffered.shift();
     if (value !== void 0) return Promise.resolve({ done: false, value });
     if (this.failure) return Promise.reject(this.failure);
     if (this.ended) return Promise.resolve({ done: true, value: void 0 });
-    return new Promise((resolve4, reject) => this.waiters.push({ resolve: resolve4, reject }));
+    const parked = new Promise((resolve4, reject) => this.waiters.push({ resolve: resolve4, reject }));
+    for (const settle of this.drainListeners.splice(0)) settle();
+    return parked;
+  }
+  /**
+   * Resolves once the consumer has taken everything pushed so far AND come back for more.
+   *
+   * For a consumer that finishes with one value before it asks for the next — the Agent SDK's input
+   * loop writes each message to the CLI and only then pulls again — that is the instant the last pushed
+   * value has been dealt with. It also resolves when the queue ends or fails: nothing more will be
+   * taken, and the caller's next step meets that state on its own.
+   */
+  whenDrained() {
+    if (this.ended || this.failure) return Promise.resolve();
+    if (this.buffered.length === 0 && this.waiters.length > 0) return Promise.resolve();
+    return new Promise((resolve4) => this.drainListeners.push(resolve4));
   }
   [Symbol.asyncIterator]() {
     return this;
@@ -26629,7 +26655,9 @@ var RealClaudeQueryHandle = class {
         // null = the session's main thread (every follow-up). A sub-agent STEER carries the child's
         // dispatch tool_use id here, which is the CLI's only addressing channel into a running child.
         parent_tool_use_id: parsed.parentToolUseId ?? null,
-        uuid: parsed.id
+        uuid: parsed.id,
+        // See ClaudeInputMessage.human: the runtime's send-now is gentle only for a person's message.
+        ...parsed.human ? { origin: { kind: "human" } } : {}
       });
     } catch (error) {
       this.outstandingInputs.delete(parsed.id);
@@ -26651,13 +26679,49 @@ var RealClaudeQueryHandle = class {
     const result = await this.awaitOpenControl(this.sdkQuery.reinitialize());
     return mapControlInitialization(result);
   }
-  async interrupt() {
+  async interrupt(options) {
     this.assertOpen();
-    await this.ready();
+    const init = await this.ready();
     this.assertOpen();
+    if (options?.sendNow && init.capabilities.includes(CLAUDE_CLI_CAPABILITY_SEND_NOW)) {
+      const sent = await this.sendNow(options.sendNow.messageId);
+      if (sent) return sent;
+    }
     const receipt = await this.awaitOpenControl(this.sdkQuery.interrupt());
     if (!receipt) return void 0;
-    return { stillQueued: boundedStringArray(receipt.still_queued, "interrupt.stillQueued", 256, 512).map((id2, index) => boundedId(id2, `interrupt.stillQueued[${index}]`)) };
+    return { stillQueued: stillQueuedIds(receipt.still_queued) };
+  }
+  // The runtime's own send-now (ClaudeInterruptOptions). Undefined ⇒ it could not be asked, and the
+  // caller sends the plain interrupt it would have sent before this existed.
+  //
+  // THE ENVELOPE IS WRITTEN HERE, unlike `cancelInput`'s: SDK 0.3.296 has a method for a plain
+  // interrupt and for `cancel_queued`, and none that carries `send_now`, so the request goes through the
+  // query's own `request` — the same writer every one of its typed controls uses. The CLI advertises the
+  // field (`interrupt_send_now_v1`), and a CLI without it reads the request as a plain interrupt, which
+  // is the fallback anyway. If a later SDK drops `request`, this answers undefined and nothing is lost
+  // but the gentleness; _live_broker_send_now.mts is what would say so.
+  //
+  // ORDER: the request must not overtake the message it names. `send` only PUSHES — the SDK's input loop
+  // writes the message to the CLI on its own schedule — while a control request is written at once, so a
+  // send-now issued straight after `send` reached the CLI first and was answered `nothing_waiting`: the
+  // CLI had never heard of the message, did nothing, and the message then waited out the whole tool call
+  // (measured, 4 of 4, 2026-10-13). `whenDrained` is the SDK having written everything pushed so far.
+  async sendNow(messageId) {
+    const provider = this.sdkQuery;
+    const request = provider[CLAUDE_SDK_REQUEST_METHOD];
+    if (typeof request !== "function") return void 0;
+    const named = messageId !== void 0 && UUID_PATTERN.test(messageId) ? { message_uuid: messageId } : {};
+    await this.input.whenDrained();
+    this.assertOpen();
+    const answer = await this.awaitOpenControl(request.call(this.sdkQuery, { subtype: "interrupt", send_now: true, ...named }));
+    const response = answer?.response;
+    const outcome = CLAUDE_SEND_NOW_OUTCOMES.find((known) => known === response?.send_now);
+    return {
+      stillQueued: Array.isArray(response?.still_queued) ? stillQueuedIds(response.still_queued) : [],
+      // Absent when the CLI answered without one: it took the request as a plain interrupt, which has
+      // happened by now either way, so there is nothing left to fall back to.
+      ...outcome ? { sendNow: outcome } : {}
+    };
   }
   async stopTask(taskId) {
     this.assertOpen();
@@ -28985,9 +29049,14 @@ function runClaudeBroker(config, options = {}) {
             pendingPermissions.delete(msg.requestId);
             e13.resolve(msg.decision);
           }
-        } else if (msg.t === "interrupt") void handle.interrupt().catch(() => {
-        });
-        else if (msg.t === "cancel-input") {
+        } else if (msg.t === "interrupt") {
+          const sendNow = msg.sendNow && typeof msg.sendNow === "object" ? msg.sendNow : void 0;
+          const messageId = typeof sendNow?.messageId === "string" ? sendNow.messageId : void 0;
+          void handle.interrupt(sendNow ? { sendNow: messageId ? { messageId } : {} } : void 0).then((receipt) => {
+            if (sendNow) writeDiagnostic?.({ kind: "stderr", message: `send-now: ${receipt?.sendNow ?? "plain interrupt"}${messageId ? ` id=${messageId}` : ""}`, truncated: false });
+          }, () => {
+          });
+        } else if (msg.t === "cancel-input") {
           const requestId = msg.requestId;
           const id2 = typeof msg.id === "string" ? msg.id : "";
           void handle.cancelInput(id2).then(