@cydm/pie 1.0.41 → 1.0.42

package/dist/chunks/{chunk-OBCFKF6H.js → chunk-2GVFMYIV.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   Agent
-} from "./chunk-E3ELBCCX.js";
+} from "./chunk-JVLAKTAS.js";
 import {
   FileSystemGateway,
   Type,
@@ -11,23 +11,70 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-YCPKJCUB.js";
+} from "./chunk-NGQ3PUOC.js";
 import {
   __commonJS,
   __toESM
-} from "./chunk-TG2EQLX2.js";
+} from "./chunk-LZQXQOPJ.js";
 
-// ../../node_modules/shell-quote/quote.js
+// ../../packages/shared-headless-capabilities/node_modules/shell-quote/quote.js
 var require_quote = __commonJS({
-  "../../node_modules/shell-quote/quote.js"(exports, module) {
+  "../../packages/shared-headless-capabilities/node_modules/shell-quote/quote.js"(exports, module) {
     "use strict";
+    var OPS = (
+      /** @type {const} */
+      [
+        "||",
+        "&&",
+        ";;",
+        "|&",
+        "<(",
+        "<<<",
+        ">>",
+        ">&",
+        "<&",
+        "&",
+        ";",
+        "(",
+        ")",
+        "|",
+        "<",
+        ">"
+      ]
+    );
+    var LINE_TERMINATORS = /[\n\r\u2028\u2029]/;
+    var GLOB_SHELL_SPECIAL = /[\s#!"$&'():;<=>@\\^`|]/g;
     module.exports = function quote(xs) {
       return xs.map(function(s) {
         if (s === "") {
-          return "''";
+          return (
+            /** @type {const} */
+            "''"
+          );
         }
         if (s && typeof s === "object") {
-          return s.op.replace(/(.)/g, "\\$1");
+          if ("op" in s && s.op === "glob") {
+            if (typeof s.pattern !== "string") {
+              throw new TypeError("glob token requires a string `pattern`");
+            }
+            if (LINE_TERMINATORS.test(s.pattern)) {
+              throw new TypeError("glob `pattern` must not contain line terminators");
+            }
+            return s.pattern.replace(GLOB_SHELL_SPECIAL, "\\$&");
+          }
+          if ("op" in s && typeof s.op === "string") {
+            if (OPS.indexOf(s.op) < 0) {
+              throw new TypeError("invalid `op` value: " + JSON.stringify(s.op));
+            }
+            return s.op.replace(/[\s\S]/g, "\\$&");
+          }
+          if ("comment" in s && typeof s.comment === "string") {
+            if (LINE_TERMINATORS.test(s.comment)) {
+              throw new TypeError("`comment` must not contain line terminators");
+            }
+            return "#" + s.comment;
+          }
+          throw new TypeError("unrecognized object token shape");
         }
         if (/["\s\\]/.test(s) && !/'/.test(s)) {
           return "'" + s.replace(/(['])/g, "\\$1") + "'";
@@ -35,38 +82,67 @@ var require_quote = __commonJS({
         if (/["'\s]/.test(s)) {
           return '"' + s.replace(/(["\\$`!])/g, "\\$1") + '"';
         }
-        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}])/g, "$1\\$2");
+        return String(s).replace(/([A-Za-z]:)?([#!"$&'()*,:;<=>?@[\\\]^`{|}~])/g, "$1\\$2");
       }).join(" ");
     };
   }
 });
 
-// ../../node_modules/shell-quote/parse.js
+// ../../packages/shared-headless-capabilities/node_modules/shell-quote/parse.js
 var require_parse = __commonJS({
-  "../../node_modules/shell-quote/parse.js"(exports, module) {
+  "../../packages/shared-headless-capabilities/node_modules/shell-quote/parse.js"(exports, module) {
     "use strict";
-    var CONTROL = "(?:" + [
-      "\\|\\|",
-      "\\&\\&",
-      ";;",
-      "\\|\\&",
-      "\\<\\(",
-      "\\<\\<\\<",
-      ">>",
-      ">\\&",
-      "<\\&",
-      "[&;()|<>]"
-    ].join("|") + ")";
+    var CONTROL = (
+      /** @type {const} */
+      "(?:" + /** @type {const} */
+      [
+        "\\|\\|",
+        "\\&\\&",
+        ";;",
+        "\\|\\&",
+        "\\<\\(",
+        "\\<\\<\\<",
+        ">>",
+        ">\\&",
+        "<\\&",
+        "[&;()|<>]"
+      ].join(
+        /** @type {const} */
+        "|"
+      ) + /** @type {const} */
+      ")"
+    );
     var controlRE = new RegExp("^" + CONTROL + "$");
-    var META = "|&;()<> \\t";
-    var SINGLE_QUOTE = '"((\\\\"|[^"])*?)"';
-    var DOUBLE_QUOTE = "'((\\\\'|[^'])*?)'";
+    var META = (
+      /** @type {const} */
+      "|&;()<> \\t"
+    );
+    var SINGLE_QUOTE = (
+      /** @type {const} */
+      "'([^']*?)'"
+    );
+    var DOUBLE_QUOTE = (
+      /** @type {const} */
+      '"((\\\\"|[^"])*?)"'
+    );
     var hash = /^#$/;
-    var SQ = "'";
-    var DQ = '"';
-    var DS = "$";
+    var SQ = (
+      /** @type {const} */
+      "'"
+    );
+    var DQ = (
+      /** @type {const} */
+      '"'
+    );
+    var DS = (
+      /** @type {const} */
+      "$"
+    );
     var TOKEN = "";
-    var mult = 4294967296;
+    var mult = (
+      /** @type {const} */
+      4294967296
+    );
     for (i = 0; i < 4; i++) {
       TOKEN += (mult * Math.random()).toString(16);
     }
@@ -77,7 +153,7 @@ var require_parse = __commonJS({
       var matches = [];
       var matchObj;
       while (matchObj = r.exec(s)) {
-        matches.push(matchObj);
+        matches[matches.length] = matchObj;
         if (r.lastIndex === matchObj.index) {
           r.lastIndex += 1;
         }
@@ -102,11 +178,12 @@ var require_parse = __commonJS({
         opts = {};
       }
       var BS = opts.escape || "\\";
+      var ifs = opts.splitUnquoted === true ? " 	\n" : typeof opts.splitUnquoted === "string" ? opts.splitUnquoted : "";
       var BAREWORD = "(\\" + BS + `['"` + META + `]|[^\\s'"` + META + "])+";
       var chunker = new RegExp([
         "(" + CONTROL + ")",
         // control chars
-        "(" + BAREWORD + "|" + SINGLE_QUOTE + "|" + DOUBLE_QUOTE + ")+"
+        "(" + BAREWORD + "|" + DOUBLE_QUOTE + "|" + SINGLE_QUOTE + ")+"
       ].join("|"), "g");
       var matches = matchAll(string, chunker);
       if (matches.length === 0) {
@@ -122,11 +199,17 @@ var require_parse = __commonJS({
           return void 0;
         }
         if (controlRE.test(s)) {
-          return { op: s };
+          return (
+            /** @type {ControlOperator} */
+            { op: s }
+          );
         }
         var quote = false;
         var esc = false;
         var out = "";
+        var words = [];
+        var sawQuote = false;
+        var pendingNw = null;
         var isGlob = false;
         var i2;
         function parseEnvVar() {
@@ -139,10 +222,20 @@ var require_parse = __commonJS({
             if (s.charAt(i2) === "}") {
               throw new Error("Bad substitution: " + s.slice(i2 - 2, i2 + 1));
             }
-            varend = s.indexOf("}", i2);
-            if (varend < 0) {
+            var depth = 1;
+            varend = i2;
+            while (depth > 0 && varend < s.length) {
+              if (s.charAt(varend) === "{" && s.charAt(varend - 1) === "$") {
+                depth += 1;
+              } else if (s.charAt(varend) === "}") {
+                depth -= 1;
+              }
+              varend += 1;
+            }
+            if (depth !== 0) {
               throw new Error("Bad substitution: " + s.slice(i2));
             }
+            varend -= 1;
             varname = s.slice(i2, varend);
             i2 = varend;
           } else if (/[*@#?$!_-]/.test(char)) {
@@ -156,13 +249,40 @@ var require_parse = __commonJS({
               i2 = s.length;
             } else {
               varname = slicedFromI.slice(0, varend.index);
-              i2 += varend.index - 1;
+              i2 += /** @type {number} */
+              varend.index - 1;
+            }
+          }
+          return getVar(
+            /** @type {NonNullable<typeof env>} */
+            env,
+            "",
+            varname
+          );
+        }
+        function flushRun() {
+          if (pendingNw === null) {
+            return;
+          }
+          if (pendingNw === 0) {
+            if (out !== "") {
+              words[words.length] = out;
+              out = "";
+            }
+          } else {
+            words[words.length] = out;
+            out = "";
+            for (var fe = 1; fe < pendingNw; fe += 1) {
+              words[words.length] = "";
             }
           }
-          return getVar(env, "", varname);
+          pendingNw = null;
         }
         for (i2 = 0; i2 < s.length; i2++) {
           var c = s.charAt(i2);
+          if (ifs && c !== DS) {
+            flushRun();
+          }
           isGlob = isGlob || !quote && (c === "*" || c === "?");
           if (esc) {
             out += c;
@@ -189,58 +309,113 @@ var require_parse = __commonJS({
             }
           } else if (c === DQ || c === SQ) {
             quote = c;
+            sawQuote = true;
           } else if (controlRE.test(c)) {
-            return { op: s };
+            return (
+              /** @type {ControlOperator} */
+              { op: s }
+            );
           } else if (hash.test(c)) {
             commented = true;
             var commentObj = { comment: string.slice(match2.index + i2 + 1) };
             if (out.length) {
-              return [out, commentObj];
+              return (
+                /** @type {const} */
+                [out, commentObj]
+              );
             }
-            return [commentObj];
+            return (
+              /** @type {const} */
+              [commentObj]
+            );
           } else if (c === BS) {
             esc = true;
           } else if (c === DS) {
-            out += parseEnvVar();
+            var value = parseEnvVar();
+            if (!ifs) {
+              out += value;
+            } else {
+              for (var vi = 0; vi < value.length; vi += 1) {
+                var vc = value.charAt(vi);
+                if (ifs.indexOf(vc) < 0) {
+                  flushRun();
+                  out += vc;
+                } else if (pendingNw === null) {
+                  pendingNw = vc === " " || vc === "	" || vc === "\n" ? 0 : 1;
+                } else if (vc !== " " && vc !== "	" && vc !== "\n") {
+                  pendingNw += 1;
+                }
+              }
+            }
           } else {
             out += c;
           }
         }
         if (isGlob) {
-          return { op: "glob", pattern: out };
+          return (
+            /** @type {GlobPattern} */
+            { op: "glob", pattern: out }
+          );
+        }
+        if (ifs) {
+          if (pendingNw !== null && pendingNw > 0) {
+            words[words.length] = out;
+            out = "";
+            for (var te = 1; te < pendingNw; te += 1) {
+              words[words.length] = "";
+            }
+          }
+          if (out !== "" || sawQuote && words.length === 0) {
+            words[words.length] = out;
+          }
+          return words;
         }
         return out;
-      }).reduce(function(prev, arg) {
-        return typeof arg === "undefined" ? prev : prev.concat(arg);
-      }, []);
+      }).reduce(
+        function(prev, arg) {
+          if (typeof arg === "undefined") {
+            return prev;
+          }
+          [].concat(arg).forEach(function(entry) {
+            prev[prev.length] = entry;
+          });
+          return prev;
+        },
+        /** @type {ParseEntry[]} */
+        []
+      );
     }
     module.exports = function parse2(s, env, opts) {
       var mapped = parseInternal(s, env, opts);
       if (typeof env !== "function") {
         return mapped;
       }
-      return mapped.reduce(function(acc, s2) {
-        if (typeof s2 === "object") {
-          return acc.concat(s2);
-        }
-        var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
-        if (xs.length === 1) {
-          return acc.concat(xs[0]);
-        }
-        return acc.concat(xs.filter(Boolean).map(function(x) {
-          if (startsWithToken.test(x)) {
-            return JSON.parse(x.split(TOKEN)[1]);
+      return mapped.reduce(
+        function(acc, s2) {
+          if (typeof s2 === "object") {
+            acc[acc.length] = s2;
+            return acc;
           }
-          return x;
-        }));
-      }, []);
+          var xs = s2.split(RegExp("(" + TOKEN + ".*?" + TOKEN + ")", "g"));
+          if (xs.length === 1) {
+            acc[acc.length] = xs[0];
+            return acc;
+          }
+          xs.filter(Boolean).forEach(function(x) {
+            acc[acc.length] = startsWithToken.test(x) ? JSON.parse(x.split(TOKEN)[1]) : x;
+          });
+          return acc;
+        },
+        /** @type {ParseEntry[]} */
+        []
+      );
     };
   }
 });
 
-// ../../node_modules/shell-quote/index.js
+// ../../packages/shared-headless-capabilities/node_modules/shell-quote/index.js
 var require_shell_quote = __commonJS({
-  "../../node_modules/shell-quote/index.js"(exports) {
+  "../../packages/shared-headless-capabilities/node_modules/shell-quote/index.js"(exports) {
     "use strict";
     exports.quote = require_quote();
     exports.parse = require_parse();
@@ -3411,6 +3586,68 @@ var SessionManager = class {
     this.activeSession.isDirty = true;
     return entry;
   }
+  /**
+   * Append an extension-owned custom entry to the active path. Custom
+   * entries persist with the session tree (they follow fork branches) but
+   * never enter the LLM message context.
+   */
+  appendCustomEntry(customType, data) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    if (!customType || typeof customType !== "string") {
+      throw new Error("appendCustomEntry requires a non-empty customType");
+    }
+    const entry = {
+      id: generateEntryId(),
+      parentId: this.activeSession.activeEntryId,
+      type: "custom",
+      timestamp: Date.now(),
+      customType,
+      data
+    };
+    this.activeSession.entries.push(entry);
+    this.activeSession.activeEntryId = entry.id;
+    this.activeSession.isDirty = true;
+    return entry;
+  }
+  /** Get the custom entries of one kind on the current active path, oldest first. */
+  getCustomEntries(customType) {
+    if (!this.activeSession) return [];
+    return this.getPathToEntry(this.activeSession.activeEntryId ?? "").filter((entry) => entry.type === "custom" && entry.customType === customType);
+  }
+  /** Set or clear a bookmark label on an entry. Labels persist with the session. */
+  setLabel(entryId, label) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    const entry = this.activeSession.entries.find((candidate) => candidate.id === entryId);
+    if (!entry) {
+      throw new Error(`Entry not found: ${entryId}`);
+    }
+    if (label === void 0 || label === "") {
+      delete entry.label;
+    } else {
+      entry.label = label;
+    }
+    this.activeSession.isDirty = true;
+  }
+  getLabel(entryId) {
+    if (!this.activeSession) return void 0;
+    return this.activeSession.entries.find((candidate) => candidate.id === entryId)?.label;
+  }
+  /** Set a manual display name for the active session (never auto-overwritten). */
+  setSessionName(name) {
+    if (!this.activeSession) {
+      throw new Error("No active session");
+    }
+    this.activeSession.metadata.name = name;
+    this.activeSession.metadata.nameSource = "manual";
+    this.activeSession.isDirty = true;
+  }
+  getSessionName() {
+    return this.activeSession?.metadata.nameSource === "manual" ? this.activeSession?.metadata.name : void 0;
+  }
   /**
    * Update messages (legacy compatibility - rebuilds tree)
    * @deprecated Use addMessage() instead
@@ -6369,6 +6606,97 @@ function buildPathResolutionDescription(sandboxRoot, options) {
   return `Available roots: ${rootSummaries.join("; ")}. ${defaultSentence} ${allowlistSentence}`.trim();
 }
 
+// ../../packages/shared-headless-capabilities/src/builtin/fs/utf8.ts
+function encodeUtf8(text) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(text);
+  }
+  const out = [];
+  for (let i = 0; i < text.length; i += 1) {
+    let codePoint = text.charCodeAt(i);
+    if (codePoint >= 55296 && codePoint <= 56319) {
+      const low = i + 1 < text.length ? text.charCodeAt(i + 1) : 0;
+      if (low >= 56320 && low <= 57343) {
+        codePoint = 65536 + (codePoint - 55296 << 10) + (low - 56320);
+        i += 1;
+      } else {
+        codePoint = 65533;
+      }
+    } else if (codePoint >= 56320 && codePoint <= 57343) {
+      codePoint = 65533;
+    }
+    if (codePoint < 128) {
+      out.push(codePoint);
+    } else if (codePoint < 2048) {
+      out.push(192 | codePoint >> 6, 128 | codePoint & 63);
+    } else if (codePoint < 65536) {
+      out.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+    } else {
+      out.push(
+        240 | codePoint >> 18,
+        128 | codePoint >> 12 & 63,
+        128 | codePoint >> 6 & 63,
+        128 | codePoint & 63
+      );
+    }
+  }
+  return new Uint8Array(out);
+}
+function utf8ByteLength2(text) {
+  return encodeUtf8(text).length;
+}
+function probeUtf8Sequence(bytes, offset) {
+  const lead = bytes[offset] ?? 0;
+  if (lead < 128) return { status: "complete", codePoint: lead, width: 1 };
+  if (lead < 194 || lead > 244) return { status: "invalid", width: 1 };
+  const width = lead < 224 ? 2 : lead < 240 ? 3 : 4;
+  let minFirst = 128;
+  let maxFirst = 191;
+  if (lead === 224) minFirst = 160;
+  else if (lead === 237) maxFirst = 159;
+  else if (lead === 240) minFirst = 144;
+  else if (lead === 244) maxFirst = 143;
+  let codePoint = lead & (width === 2 ? 31 : width === 3 ? 15 : 7);
+  for (let k = 1; k < width; k += 1) {
+    const byte = bytes[offset + k];
+    if (byte === void 0) return { status: "incomplete" };
+    const min = k === 1 ? minFirst : 128;
+    const max = k === 1 ? maxFirst : 191;
+    if (byte < min || byte > max) return { status: "invalid", width: k };
+    codePoint = codePoint << 6 | byte & 63;
+  }
+  return { status: "complete", codePoint, width };
+}
+function createLenientStreamingDecoder() {
+  let pending = [];
+  return {
+    decode(bytes, options) {
+      const chunk = bytes ?? new Uint8Array(0);
+      const combined = pending.concat(Array.from(chunk));
+      const flush = options?.stream !== true;
+      let out = "";
+      let i = 0;
+      while (i < combined.length) {
+        const probe = probeUtf8Sequence(combined, i);
+        if (probe.status === "incomplete") {
+          if (flush) {
+            out += String.fromCodePoint(65533);
+            i = combined.length;
+          } else {
+            pending = combined.slice(i);
+            return out;
+          }
+          continue;
+        }
+        out += String.fromCodePoint(probe.status === "complete" ? probe.codePoint : 65533);
+        i += probe.width;
+      }
+      pending = [];
+      return out;
+    }
+  };
+}
+
 // ../../packages/shared-headless-capabilities/src/builtin/fs/truncate.ts
 var DEFAULT_MAX_LINES = 2e3;
 var DEFAULT_MAX_BYTES = 50 * 1024;
@@ -6385,7 +6713,7 @@ function formatSize(bytes) {
 function truncateHead(content, options = {}) {
   const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-  const totalBytes = Buffer.byteLength(content, "utf-8");
+  const totalBytes = utf8ByteLength2(content);
   const lines = content.split("\n");
   const totalLines = lines.length;
   if (totalLines <= maxLines && totalBytes <= maxBytes) {
@@ -6403,7 +6731,7 @@ function truncateHead(content, options = {}) {
       maxBytes
     };
   }
-  const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
+  const firstLineBytes = utf8ByteLength2(lines[0]);
   if (firstLineBytes > maxBytes) {
     return {
       content: "",
@@ -6424,7 +6752,7 @@ function truncateHead(content, options = {}) {
   let truncatedBy = "lines";
   for (let i = 0; i < lines.length && i < maxLines; i++) {
     const line = lines[i];
-    const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+    const lineBytes = utf8ByteLength2(line) + (i > 0 ? 1 : 0);
     if (outputBytesCount + lineBytes > maxBytes) {
       truncatedBy = "bytes";
       break;
@@ -6436,7 +6764,7 @@ function truncateHead(content, options = {}) {
     truncatedBy = "lines";
   }
   const outputContent = outputLinesArr.join("\n");
-  const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+  const finalOutputBytes = utf8ByteLength2(outputContent);
   return {
     content: outputContent,
     truncated: true,
@@ -7007,39 +7335,92 @@ function detectTextOnlyBinary(input, filePath, prefixMayBeTruncated) {
   return detectBinaryKind(filePath) ?? { kind: "document", mimeType: "application/octet-stream" };
 }
 async function readImageInfo(path4, fs2) {
-  if (typeof Buffer === "undefined") {
-    return void 0;
-  }
   try {
-    const base64 = await fs2.readFile(path4, "base64");
-    const bytes = Buffer.from(base64, "base64");
-    if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    let base64 = "";
+    const size = (await fs2.stat(path4).catch(() => void 0))?.size ?? 0;
+    if (typeof fs2.readFile === "function") {
+      base64 = await fs2.readFile(path4, "base64").catch(() => "");
+    }
+    if (!base64 && size > 0 && typeof fs2.readFileSync === "function") {
+      base64 = fs2.readFileSync(path4, "base64");
+    }
+    if (!base64) {
+      console.error(`[pie] readImageInfo got empty base64 for ${path4}`);
+      return void 0;
+    }
+    const bytes = decodeBase64ToBytes(base64);
+    if (bytes.length === 0) {
+      console.error(`[pie] readImageInfo decoded 0 bytes for ${path4} (base64 length ${base64.length})`);
+      return void 0;
+    }
+    const pngMagic = [137, 80, 78, 71, 13, 10, 26, 10];
+    if (bytes.length >= 8 && pngMagic.every((byte, index) => bytes[index] === byte)) {
       return { mimeType: "image/png", base64, ...parsePngDimensions(bytes) };
     }
     if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
       return { mimeType: "image/jpeg", base64, ...parseJpegDimensions(bytes) };
     }
     if (bytes.length >= 6) {
-      const gifHeader = bytes.subarray(0, 6).toString("ascii");
+      const gifHeader = asciiAt(bytes, 0, 6);
       if (gifHeader === "GIF87a" || gifHeader === "GIF89a") {
         return { mimeType: "image/gif", base64, ...parseGifDimensions(bytes) };
       }
     }
-    if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    if (bytes.length >= 12 && asciiAt(bytes, 0, 4) === "RIFF" && asciiAt(bytes, 8, 12 - 8) === "WEBP") {
       return { mimeType: "image/webp", base64, ...parseWebpDimensions(bytes) };
     }
-  } catch {
+  } catch (error) {
+    console.error(`[pie] readImageInfo failed for ${path4}: ${error instanceof Error ? error.message : String(error)}`);
     return void 0;
   }
   return void 0;
 }
+function decodeBase64ToBytes(base64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(base64, "base64");
+  }
+  const clean = base64.replace(/[^A-Za-z0-9+/=]/g, "");
+  if (clean.length % 4 !== 0) {
+    return new Uint8Array(0);
+  }
+  const lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const bytes = new Uint8Array(clean.length / 4 * 3);
+  let at = 0;
+  for (let i = 0; i < clean.length; i += 4) {
+    const padding = clean[i + 2] === "=" ? clean[i + 3] === "=" ? 2 : 1 : 0;
+    const n = lookup.indexOf(clean[i]) << 18 | lookup.indexOf(clean[i + 1]) << 12 | (padding < 2 ? lookup.indexOf(clean[i + 2]) << 6 : 0) | (padding < 1 ? lookup.indexOf(clean[i + 3]) : 0);
+    bytes[at++] = n >> 16 & 255;
+    if (padding < 2) bytes[at++] = n >> 8 & 255;
+    if (padding < 1) bytes[at++] = n & 255;
+  }
+  return bytes.subarray(0, at);
+}
+function readUIntBE(bytes, offset, length) {
+  let value = 0;
+  for (let i = 0; i < length; i += 1) {
+    value = value * 256 + bytes[offset + i];
+  }
+  return value;
+}
+function readUIntLE(bytes, offset, length) {
+  let value = 0;
+  for (let i = length - 1; i >= 0; i -= 1) {
+    value = value * 256 + bytes[offset + i];
+  }
+  return value;
+}
+function asciiAt(bytes, offset, length) {
+  let text = "";
+  for (let i = 0; i < length; i += 1) text += String.fromCharCode(bytes[offset + i]);
+  return text;
+}
 function parsePngDimensions(bytes) {
   if (bytes.length < 24) {
     return {};
   }
   return {
-    width: bytes.readUInt32BE(16),
-    height: bytes.readUInt32BE(20)
+    width: readUIntBE(bytes, 16, 4),
+    height: readUIntBE(bytes, 20, 4)
   };
 }
 function parseGifDimensions(bytes) {
@@ -7047,8 +7428,8 @@ function parseGifDimensions(bytes) {
     return {};
   }
   return {
-    width: bytes.readUInt16LE(6),
-    height: bytes.readUInt16LE(8)
+    width: readUIntLE(bytes, 6, 2),
+    height: readUIntLE(bytes, 8, 2)
   };
 }
 function parseJpegDimensions(bytes) {
@@ -7066,15 +7447,15 @@ function parseJpegDimensions(bytes) {
     if (offset + 2 > bytes.length) {
       break;
     }
-    const segmentLength = bytes.readUInt16BE(offset);
+    const segmentLength = readUIntBE(bytes, offset, 2);
     if (segmentLength < 2 || offset + segmentLength > bytes.length) {
       break;
     }
     const isStartOfFrame = marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207;
     if (isStartOfFrame && segmentLength >= 7) {
       return {
-        height: bytes.readUInt16BE(offset + 3),
-        width: bytes.readUInt16BE(offset + 5)
+        height: readUIntBE(bytes, offset + 3, 2),
+        width: readUIntBE(bytes, offset + 5, 2)
       };
     }
     offset += segmentLength;
@@ -7085,21 +7466,21 @@ function parseWebpDimensions(bytes) {
   if (bytes.length < 30) {
     return {};
   }
-  const chunkType = bytes.subarray(12, 16).toString("ascii");
+  const chunkType = asciiAt(bytes, 12, 4);
   if (chunkType === "VP8X" && bytes.length >= 30) {
     return {
-      width: 1 + bytes.readUIntLE(24, 3),
-      height: 1 + bytes.readUIntLE(27, 3)
+      width: 1 + readUIntLE(bytes, 24, 3),
+      height: 1 + readUIntLE(bytes, 27, 3)
     };
   }
   if (chunkType === "VP8 " && bytes.length >= 30) {
     return {
-      width: bytes.readUInt16LE(26) & 16383,
-      height: bytes.readUInt16LE(28) & 16383
+      width: readUIntLE(bytes, 26, 2) & 16383,
+      height: readUIntLE(bytes, 28, 2) & 16383
     };
   }
   if (chunkType === "VP8L" && bytes.length >= 25) {
-    const bits = bytes.readUInt32LE(21);
+    const bits = readUIntLE(bytes, 21, 4);
     return {
       width: (bits & 16383) + 1,
       height: (bits >> 14 & 16383) + 1
@@ -10081,7 +10462,7 @@ function appendMergedContentMatches(input) {
       const lineNumber = lineIndex + 1;
       const formatted = matches.has(lineIndex) ? `${input.relativePath}:${lineNumber}: ${text}` : `${input.relativePath}-${lineNumber}- ${text}`;
       input.outputLines.push(formatted);
-      outputBytes += Buffer.byteLength(formatted, "utf8") + (input.outputLines.length > 1 ? 1 : 0);
+      outputBytes += utf8ByteLength2(formatted) + (input.outputLines.length > 1 ? 1 : 0);
       if (outputBytes > DEFAULT_MAX_BYTES) return { outputBytes, linesTruncated, outputBudgetReached: true };
     }
   }
@@ -12222,6 +12603,112 @@ function extractOpenAIResponsesContent(response, originalQuery) {
   const text = textChunks.join("\n").trim();
   return { text, sources: uniqueSources(sources), results: text ? [makeTextSegment(text)] : [], actualQueries: [originalQuery] };
 }
+var MAX_PLAIN_PAYLOAD_CHARS = 2 * 1024 * 1024;
+async function readOpenAIResponsesSearchStream(response, originalQuery) {
+  if (!response.body) {
+    const statusDetail = await response.text().then((text) => text.slice(0, 200)).catch(() => "");
+    throw new Error(`Responses web_search returned no SSE body (HTTP ${response.status}${statusDetail ? `: ${statusDetail}` : ""}).`);
+  }
+  const reader = response.body.getReader();
+  const decoder = typeof TextDecoder !== "undefined" ? new TextDecoder() : createLenientStreamingDecoder();
+  const outputItems = [];
+  let completedOutput = [];
+  let textDeltas = "";
+  let buffer = "";
+  let dataLines = [];
+  let plainText = "";
+  let completed = false;
+  let searched = false;
+  const handleEvent = (data) => {
+    if (!data || data === "[DONE]") return;
+    const event = JSON.parse(data);
+    if (!isRecord4(event)) return;
+    const type = event.type;
+    if (type === "response.web_search_call.completed") searched = true;
+    if (type === "response.output_item.done" && isRecord4(event.item)) {
+      if (event.item.type === "web_search_call" && event.item.status === "completed") searched = true;
+      if (event.item.type === "message") outputItems.push(event.item);
+    }
+    if (type === "response.output_text.delta" && typeof event.delta === "string") textDeltas += event.delta;
+    if (type === "response.completed") {
+      completed = true;
+      const result = isRecord4(event.response) ? event.response : {};
+      completedOutput = Array.isArray(result.output) ? result.output : [];
+      const toolUsage = isRecord4(result.tool_usage) ? result.tool_usage : {};
+      const webSearch = isRecord4(toolUsage.web_search) ? toolUsage.web_search : {};
+      if (typeof webSearch.num_requests === "number" && webSearch.num_requests > 0) searched = true;
+    }
+    if (type === "response.failed" || type === "response.incomplete" || type === "error") {
+      const result = isRecord4(event.response) ? event.response : {};
+      const error = isRecord4(event.error) ? event.error : isRecord4(result.error) ? result.error : {};
+      throw new Error(`Responses web_search ${type}: ${String(error.message || error.code || "upstream error")}`);
+    }
+  };
+  const handleLine = (rawLine) => {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "") {
+      const data = dataLines.join("\n");
+      dataLines = [];
+      handleEvent(data);
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).trimStart());
+    } else {
+      plainText += line;
+      if (plainText.length > MAX_PLAIN_PAYLOAD_CHARS) {
+        throw new Error(`Responses web_search plain-text payload exceeded ${MAX_PLAIN_PAYLOAD_CHARS} characters.`);
+      }
+    }
+  };
+  let streamDrained = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) streamDrained = true;
+      buffer += decoder.decode(value, { stream: !done });
+      if (buffer.length > MAX_PLAIN_PAYLOAD_CHARS) {
+        throw new Error(`Responses web_search line exceeded ${MAX_PLAIN_PAYLOAD_CHARS} characters.`);
+      }
+      let newline;
+      while ((newline = buffer.indexOf("\n")) !== -1) {
+        handleLine(buffer.slice(0, newline));
+        buffer = buffer.slice(newline + 1);
+      }
+      if (completed || done) break;
+    }
+    if (!completed) {
+      if (buffer) handleLine(buffer);
+      if (dataLines.length) handleEvent(dataLines.join("\n"));
+    }
+  } finally {
+    if (!streamDrained) await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+  if (!completed && plainText.trim().startsWith("{")) {
+    try {
+      const document = JSON.parse(plainText);
+      if (isRecord4(document) && Array.isArray(document.output)) {
+        completed = true;
+        completedOutput = document.output;
+        const toolUsage = isRecord4(document.tool_usage) ? document.tool_usage : {};
+        const webSearch = isRecord4(toolUsage.web_search) ? toolUsage.web_search : {};
+        if (typeof webSearch.num_requests === "number" && webSearch.num_requests > 0) searched = true;
+        for (const item of completedOutput) {
+          if (isRecord4(item) && item.type === "web_search_call" && item.status === "completed") searched = true;
+          if (isRecord4(item) && item.type === "message" && Array.isArray(item.content)) {
+            for (const block of item.content) {
+              if (isRecord4(block) && Array.isArray(block.annotations) && block.annotations.length > 0) searched = true;
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (!completed) throw new Error("Responses web_search stream ended before response.completed.");
+  if (!searched) throw new Error("Responses web_search completed without a search call.");
+  const output = outputItems.length ? outputItems : completedOutput;
+  return extractOpenAIResponsesContent({ output, output_text: output.length ? void 0 : textDeltas }, originalQuery);
+}
 function extractChatCompletionsContent(response, originalQuery) {
   const body = isRecord4(response) ? response : {};
   const sources = [];
@@ -12263,6 +12750,9 @@ async function runOpenAIResponsesSearch(params) {
     },
     body: JSON.stringify({
       model: params.model.id,
+      store: false,
+      stream: true,
+      tool_choice: { type: "web_search" },
       input: [{
         role: "user",
         content: [{
@@ -12279,7 +12769,7 @@ Perform a web search for this query and summarize the useful results with source
     const errorBody = await response.text().catch(() => "");
     throw new Error(`Responses API error ${response.status}: ${errorBody}`);
   }
-  return extractOpenAIResponsesContent(await response.json(), params.input.query);
+  return readOpenAIResponsesSearchStream(response, params.input.query);
 }
 async function runAnthropicNativeSearch(params) {
   const baseUrl = (params.model.baseUrl || "").replace(/\/+$/, "");
@@ -12580,8 +13070,9 @@ function createSharedWebSearchTool(deps) {
           }
           const qualityWarnings = evaluateSearchQuality(search);
           const durationSeconds = (Date.now() - start) / 1e3;
-          if (qualityWarnings.length > 0) {
-            lastFailureReason = `Provider returned low-quality web_search results: ${qualityWarnings.join(", ")}`;
+          const hardQualityFailures = qualityWarnings.filter((warning) => warning !== "only_homepage_or_search_page_sources");
+          if (hardQualityFailures.length > 0) {
+            lastFailureReason = `Provider returned low-quality web_search results: ${hardQualityFailures.join(", ")}`;
             lastFailureCategory = "low_quality_result";
             attempts.push(makeAttempt({
               model: searchModel,
@@ -12591,7 +13082,7 @@ function createSharedWebSearchTool(deps) {
               fallbackReason: lastFailureReason,
               sourceCount: search.sources.length,
               durationSeconds,
-              qualityWarnings
+              qualityWarnings: hardQualityFailures
             }));
             continue;
           }
@@ -12625,6 +13116,7 @@ function createSharedWebSearchTool(deps) {
               sources: search.sources,
               actualQueries: search.actualQueries,
               results: search.results,
+              qualityWarnings,
               attempts
             },
             isError: false