@cydm/pie 2.7.13 → 2.7.15

package/dist/chunks/{chunk-D7RMNFVM.js → chunk-CLEPSTWH.js}

@@ -7,12 +7,12 @@ import {
   defaultShellKindForPlatform,
   interpretShellExit,
   requestInteraction
-} from "./chunk-CIFC6QVB.js";
+} from "./chunk-C5UTDL3S.js";
 import {
   EMPTY_ASSISTANT_CONTENT_ERROR,
   OPENAI_COMPAT_PROTOCOL_ERROR_CODE,
   getLogger
-} from "./chunk-R46YPPTU.js";
+} from "./chunk-NM2JLPJ6.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";

package/dist/chunks/chunk-F7EBZTZO.js

@@ -0,0 +1,26 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+
+// src/files/image-format.ts
+import * as fs from "node:fs";
+function detectImageMime(bytes) {
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return { mime: "image/jpeg", ext: ".jpg" };
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) return { mime: "image/png", ext: ".png" };
+  if (bytes.length >= 6 && (bytes.subarray(0, 6).equals(Buffer.from("GIF87a")) || bytes.subarray(0, 6).equals(Buffer.from("GIF89a")))) return { mime: "image/gif", ext: ".gif" };
+  if (bytes.length >= 12 && bytes.subarray(0, 4).equals(Buffer.from("RIFF")) && bytes.subarray(8, 12).equals(Buffer.from("WEBP"))) return { mime: "image/webp", ext: ".webp" };
+  return { mime: "application/octet-stream", ext: ".bin" };
+}
+function readImageFormat(filePath) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const header = Buffer.alloc(16);
+    const count = fs.readSync(fd, header, 0, header.length, 0);
+    return detectImageMime(header.subarray(0, count));
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+export {
+  detectImageMime,
+  readImageFormat
+};

package/dist/chunks/{chunk-R46YPPTU.js → chunk-NM2JLPJ6.js}

@@ -829,6 +829,14 @@ var SHA256 = class extends HashMD {
 var sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
 
 // ../../packages/platform/src/sha256.ts
+var utf8Owner;
+function tryCreateUtf8Sha256Hasher() {
+  try {
+    return utf8Owner?.factory();
+  } catch {
+    return void 0;
+  }
+}
 function createSha256Hasher() {
   const hash = sha256.create();
   return {
@@ -2381,20 +2389,41 @@ var NodeHttpClient = class {
               waiting = null;
               w(value);
             };
+            let pendingFailureLog = null;
+            let failureLogged = false;
+            const classifyFailure = (e) => {
+              if (signal?.aborted === true || isAbortErrorMessage(e.message)) {
+                return { level: "INFO", message: `Request [${reqTag}] SSE stream aborted by caller`, extra: { error: e.message } };
+              }
+              if (requestTimeoutError) {
+                return { level: "WARN", message: `Request [${reqTag}] SSE stream failed (request timeout)`, extra: { error: e.message } };
+              }
+              if (e.message === "SSE stream aborted" || e.message === "SSE stream closed before end" || e.message === "SSE stream ended before response completed") {
+                return { level: "WARN", message: `Request [${reqTag}] SSE stream closed by remote`, extra: { error: e.message } };
+              }
+              return { level: "ERROR", message: `Request [${reqTag}] SSE stream error`, extra: { error: e.message } };
+            };
+            const logFailureIfDelivered = () => {
+              if (failureLogged || !pendingFailureLog) return;
+              failureLogged = true;
+              const entry = pendingFailureLog;
+              pendingFailureLog = null;
+              logHttp(entry.level, entry.message, entry.extra);
+            };
+            const logUndeliveredFailure = () => {
+              if (failureLogged || !pendingFailureLog) return;
+              failureLogged = true;
+              const entry = pendingFailureLog;
+              pendingFailureLog = null;
+              logHttp("DEBUG", `${entry.message} (not consumed by the reader)`, entry.extra);
+            };
             const failStream = (e) => {
               if (done && error) return;
+              const firstFailure = !error;
               error = e;
               done = true;
+              if (firstFailure) pendingFailureLog = classifyFailure(e);
               wake({ done: true, value: void 0 });
-              if (signal?.aborted === true || isAbortErrorMessage(e.message)) {
-                logHttp("INFO", `Request [${reqTag}] SSE stream aborted by caller`, { error: e.message });
-              } else if (requestTimeoutError) {
-                logHttp("WARN", `Request [${reqTag}] SSE stream failed (request timeout)`, { error: e.message });
-              } else if (e.message === "SSE stream aborted" || e.message === "SSE stream closed before end" || e.message === "SSE stream ended before response completed") {
-                logHttp("WARN", `Request [${reqTag}] SSE stream closed by remote`, { error: e.message });
-              } else {
-                logHttp("ERROR", `Request [${reqTag}] SSE stream error`, { error: e.message });
-              }
             };
             const flushBuffer = (final = false) => {
               if (final) {
@@ -2454,16 +2483,19 @@ var NodeHttpClient = class {
               });
             });
             res.on("error", (e) => {
+              if (/aborted|econnreset|socket hang up/i.test(e.message)) {
+                failStream(requestTimeoutError ?? new Error("SSE stream aborted"));
+                return;
+              }
               failStream(requestTimeoutError ?? e);
             });
             res.on("aborted", () => {
+              if (consumerClosed || done) return;
               failStream(requestTimeoutError ?? new Error("SSE stream aborted"));
             });
             res.on("close", () => {
               if (consumerClosed) return;
-              if (!done || !res.complete) {
-                failStream(requestTimeoutError ?? new Error("SSE stream closed before end"));
-              }
+              if (!done || !res.complete) failStream(requestTimeoutError ?? new Error("SSE stream closed before end"));
             });
             try {
               while (true) {
@@ -2477,7 +2509,10 @@ var NodeHttpClient = class {
                   queueHead = 0;
                 }
                 if (done) {
-                  if (error) throw error;
+                  if (error) {
+                    logFailureIfDelivered();
+                    throw error;
+                  }
                   return;
                 }
                 const waitResult = await new Promise((r) => {
@@ -2487,6 +2522,7 @@ var NodeHttpClient = class {
               }
             } finally {
               consumerClosed = true;
+              logUndeliveredFailure();
               if (signal && abortHandler) {
                 signal.removeEventListener("abort", abortHandler);
               }
@@ -6462,100 +6498,119 @@ function jsonSha256(value) {
   return hashJson(value);
 }
 function hashJson(value, parts) {
-  const hash = createSha256Hasher();
-  const bytes = new Uint8Array(8192);
-  let used = 0;
-  const byte = (n) => {
-    bytes[used++] = n;
-    if (used === bytes.length) {
-      hash.update(bytes);
-      used = 0;
-    }
-  };
-  const emit = (text) => {
-    for (let i = 0; i < text.length; i++) {
-      const cp = text.codePointAt(i);
-      if (cp < 128) byte(cp);
-      else if (cp < 2048) {
-        byte(192 | cp >> 6);
-        byte(128 | cp & 63);
-      } else if (cp < 65536) {
-        byte(224 | cp >> 12);
-        byte(128 | cp >> 6 & 63);
-        byte(128 | cp & 63);
+  const utf8 = tryCreateUtf8Sha256Hasher();
+  try {
+    const hash = utf8 ? void 0 : createSha256Hasher();
+    const bytes = new Uint8Array(utf8 ? 0 : 8192);
+    let fragments = "";
+    let used = 0;
+    const byte = (n) => {
+      bytes[used++] = n;
+      if (used === bytes.length) {
+        hash.update(bytes);
+        used = 0;
+      }
+    };
+    const emit = (text) => {
+      if (utf8) {
+        if (fragments.length + text.length > 8192) {
+          if (fragments) utf8.updateUtf8(fragments);
+          fragments = "";
+        }
+        if (text.length >= 8192) utf8.updateUtf8(text);
+        else fragments += text;
+        return;
+      }
+      for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        if (cp < 128) byte(cp);
+        else if (cp < 2048) {
+          byte(192 | cp >> 6);
+          byte(128 | cp & 63);
+        } else if (cp < 65536) {
+          byte(224 | cp >> 12);
+          byte(128 | cp >> 6 & 63);
+          byte(128 | cp & 63);
+        } else {
+          byte(240 | cp >> 18);
+          byte(128 | cp >> 12 & 63);
+          byte(128 | cp >> 6 & 63);
+          byte(128 | cp & 63);
+          i++;
+        }
+      }
+    };
+    const string = (text) => {
+      emit('"');
+      for (let start = 0; start < text.length; ) {
+        let end = Math.min(start + 2048, text.length);
+        if (end < text.length && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319) end--;
+        const escaped = JSON.stringify(text.slice(start, end));
+        emit(escaped.slice(1, -1));
+        start = end;
+      }
+      emit('"');
+    };
+    const ancestors = /* @__PURE__ */ new Set();
+    const omitted = (v) => v === void 0 || typeof v === "function" || typeof v === "symbol";
+    const visit = (v) => {
+      if (typeof v === "string") {
+        string(v);
+        return;
+      }
+      if (v === null || typeof v !== "object") {
+        const encoded = JSON.stringify(v);
+        if (encoded === void 0) throw new TypeError("Not a JSON value");
+        emit(encoded);
+        return;
+      }
+      const prototype = Object.getPrototypeOf(v);
+      if (!Array.isArray(v) && prototype !== Object.prototype && prototype !== null || typeof v.toJSON === "function") throw new TypeError("Not a JSON snapshot");
+      if (ancestors.has(v)) throw new TypeError("Circular JSON snapshot");
+      ancestors.add(v);
+      if (Array.isArray(v)) {
+        emit("[");
+        for (let i = 0; i < v.length; i++) {
+          if (Object.getOwnPropertyDescriptor(v, i)?.get) throw new TypeError("Not a JSON snapshot");
+          if (i) emit(",");
+          visit(omitted(v[i]) ? null : v[i]);
+        }
+        emit("]");
       } else {
-        byte(240 | cp >> 18);
-        byte(128 | cp >> 12 & 63);
-        byte(128 | cp >> 6 & 63);
-        byte(128 | cp & 63);
-        i++;
+        emit("{");
+        let first = true;
+        for (const key of Object.keys(v)) {
+          if (Object.getOwnPropertyDescriptor(v, key)?.get) throw new TypeError("Not a JSON snapshot");
+          const entry = v[key];
+          if (omitted(entry)) continue;
+          if (!first) emit(",");
+          first = false;
+          string(key);
+          emit(":");
+          visit(entry);
+        }
+        emit("}");
       }
-    }
-  };
-  const string = (text) => {
-    emit('"');
-    for (let start = 0; start < text.length; ) {
-      let end = Math.min(start + 2048, text.length);
-      if (end < text.length && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319) end--;
-      const escaped = JSON.stringify(text.slice(start, end));
-      emit(escaped.slice(1, -1));
-      start = end;
-    }
-    emit('"');
-  };
-  const ancestors = /* @__PURE__ */ new Set();
-  const omitted = (v) => v === void 0 || typeof v === "function" || typeof v === "symbol";
-  const visit = (v) => {
-    if (typeof v === "string") {
-      string(v);
-      return;
-    }
-    if (v === null || typeof v !== "object") {
-      const encoded = JSON.stringify(v);
-      if (encoded === void 0) throw new TypeError("Not a JSON value");
-      emit(encoded);
-      return;
-    }
-    const prototype = Object.getPrototypeOf(v);
-    if (!Array.isArray(v) && prototype !== Object.prototype && prototype !== null || typeof v.toJSON === "function") throw new TypeError("Not a JSON snapshot");
-    if (ancestors.has(v)) throw new TypeError("Circular JSON snapshot");
-    ancestors.add(v);
-    if (Array.isArray(v)) {
+      ancestors.delete(v);
+    };
+    if (parts) {
       emit("[");
-      for (let i = 0; i < v.length; i++) {
-        if (Object.getOwnPropertyDescriptor(v, i)?.get) throw new TypeError("Not a JSON snapshot");
+      for (let i = 0; i < parts.count + parts.output.length; i++) {
         if (i) emit(",");
-        visit(omitted(v[i]) ? null : v[i]);
+        const item = i < parts.count ? parts.input[i] : parts.output[i - parts.count];
+        visit(omitted(item) ? null : item);
       }
       emit("]");
-    } else {
-      emit("{");
-      let first = true;
-      for (const key of Object.keys(v)) {
-        if (Object.getOwnPropertyDescriptor(v, key)?.get) throw new TypeError("Not a JSON snapshot");
-        const entry = v[key];
-        if (omitted(entry)) continue;
-        if (!first) emit(",");
-        first = false;
-        string(key);
-        emit(":");
-        visit(entry);
-      }
-      emit("}");
-    }
-    ancestors.delete(v);
-  };
-  if (parts) {
-    emit("[");
-    for (let i = 0; i < parts.count + parts.output.length; i++) {
-      if (i) emit(",");
-      const item = i < parts.count ? parts.input[i] : parts.output[i - parts.count];
-      visit(omitted(item) ? null : item);
-    }
-    emit("]");
-  } else visit(value);
-  if (used) hash.update(bytes.subarray(0, used));
-  return hash.digestHex();
+    } else visit(value);
+    if (utf8) {
+      if (fragments) utf8.updateUtf8(fragments);
+      return utf8.digestHex();
+    }
+    if (used) hash.update(bytes.subarray(0, used));
+    return hash.digestHex();
+  } finally {
+    utf8?.dispose();
+  }
 }
 function inputSha256(input, count = input.length, output = []) {
   return hashJson(void 0, { input, count, output });

package/dist/chunks/{chunk-HGUYS5SF.js → chunk-TDHVB2FH.js}

@@ -4,7 +4,7 @@ import {
   disposeModelTransports,
   streamSimple,
   validateToolArguments
-} from "./chunk-R46YPPTU.js";
+} from "./chunk-NM2JLPJ6.js";
 
 // ../../packages/agent-core/src/failure.ts
 function getAgentFailureMetadata(error) {

package/dist/chunks/{src-5JJZZ5H7.js → src-IY6TEIL7.js}

@@ -8,8 +8,8 @@ import {
   createToolCallerIdentity,
   getAgentFailureMetadata,
   getToolCallerIdentity
-} from "./chunk-HGUYS5SF.js";
-import "./chunk-R46YPPTU.js";
+} from "./chunk-TDHVB2FH.js";
+import "./chunk-NM2JLPJ6.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";
 export {

package/dist/chunks/{test-stream-ZBTSPU7J.js → test-stream-EXSL5TIO.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-R46YPPTU.js";
+} from "./chunk-NM2JLPJ6.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";