@pasko70/pibo 3.5.0 → 3.6.0

package/dist/shared/cache-observability.js

@@ -0,0 +1,73 @@
+import { modelInferenceCachedInputTokens, modelInferenceInputTokens, modelInferenceUncachedInputTokens, } from "./model-inference-metrics.js";
+export const CACHE_READ_DROP_RULE = "provider-cache-read-drop-v1";
+export const CACHE_READ_DROP_MIN_INPUT_TOKENS = 16_384;
+function cacheState(ratio) {
+    if (ratio === undefined)
+        return "unknown";
+    if (ratio <= 0.1)
+        return "cold";
+    if (ratio >= 0.8)
+        return "warm";
+    return "partial";
+}
+function elapsedMs(current, previous) {
+    if (!previous?.completedAt || !current.completedAt)
+        return undefined;
+    const before = Date.parse(previous.completedAt);
+    const after = Date.parse(current.completedAt);
+    return Number.isFinite(before) && Number.isFinite(after) && after >= before ? after - before : undefined;
+}
+/**
+ * Compares bounded provider usage counters. It does not inspect prompts, infer a
+ * provider cache key, or identify why a cache read changed.
+ */
+export function observeCacheUsage(current, previous, options = {}) {
+    const inputTokens = modelInferenceInputTokens(current.metrics);
+    const cacheReadTokens = modelInferenceCachedInputTokens(current.metrics);
+    const uncachedInputTokens = modelInferenceUncachedInputTokens(current.metrics);
+    const cacheWriteTokens = Number.isFinite(current.metrics.cacheWriteTokens) && Number(current.metrics.cacheWriteTokens) >= 0
+        ? Math.floor(Number(current.metrics.cacheWriteTokens))
+        : undefined;
+    const ratio = inputTokens !== undefined && inputTokens > 0 && cacheReadTokens !== undefined && cacheReadTokens <= inputTokens
+        ? cacheReadTokens / inputTokens
+        : undefined;
+    const previousInput = modelInferenceInputTokens(previous?.metrics);
+    const previousRead = modelInferenceCachedInputTokens(previous?.metrics);
+    const previousRatio = previousInput !== undefined && previousInput > 0 && previousRead !== undefined && previousRead <= previousInput
+        ? previousRead / previousInput
+        : undefined;
+    const elapsed = elapsedMs(current, previous);
+    const observation = {
+        rule: CACHE_READ_DROP_RULE,
+        source: "provider-reported-usage",
+        cacheState: cacheState(ratio),
+        warning: "none",
+        explanation: ratio === undefined ? "insufficient-data" : "provider-usage",
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
+        ...(cacheWriteTokens === undefined ? {} : { cacheWriteTokens }),
+        ...(uncachedInputTokens === undefined ? {} : { uncachedInputTokens }),
+        ...(ratio === undefined ? {} : { cacheReadRatio: ratio }),
+        ...(previous ? { previousInferenceId: previous.id } : {}),
+        ...(previousRatio === undefined ? {} : { previousCacheReadRatio: previousRatio }),
+        ...(elapsed === undefined ? {} : { elapsedMs: elapsed }),
+    };
+    if (options.compactionBetween) {
+        observation.explanation = "compaction-between-inferences";
+        return observation;
+    }
+    if (inputTokens !== undefined && previousInput !== undefined && cacheReadTokens !== undefined && previousRead !== undefined
+        && inputTokens >= CACHE_READ_DROP_MIN_INPUT_TOKENS && previousInput >= CACHE_READ_DROP_MIN_INPUT_TOKENS
+        && ratio !== undefined && previousRatio !== undefined && previousRatio >= 0.8 && ratio <= 0.1 && cacheReadTokens < previousRead) {
+        observation.warning = "possible-cache-read-drop";
+        observation.explanation = "cache-read-ratio-dropped";
+    }
+    return observation;
+}
+export function cacheUsageWarningText(observation) {
+    if (observation.warning === "none")
+        return undefined;
+    const current = observation.cacheReadRatio === undefined ? "unknown" : `${(observation.cacheReadRatio * 100).toFixed(1)}%`;
+    const previous = observation.previousCacheReadRatio === undefined ? "unknown" : `${(observation.previousCacheReadRatio * 100).toFixed(1)}%`;
+    return `Possible cache-read drop: provider-reported cached input fell from ${previous} to ${current}. The provider metrics do not identify the cause.`;
+}

package/dist/shared/model-inference-metrics.js

@@ -6,18 +6,31 @@ export function modelInferenceInputTokens(metrics) {
     return tokenCount(metrics?.inputTokens);
 }
 export function modelInferenceCachedInputTokens(metrics) {
-    const cacheRead = tokenCount(metrics?.cacheReadTokens);
-    const cacheWrite = tokenCount(metrics?.cacheWriteTokens);
-    if (cacheRead === undefined && cacheWrite === undefined)
-        return undefined;
-    return (cacheRead ?? 0) + (cacheWrite ?? 0);
+    return tokenCount(metrics?.cacheReadTokens);
 }
 export function modelInferenceUncachedInputTokens(metrics) {
     const input = modelInferenceInputTokens(metrics);
-    if (input === undefined)
+    const cached = modelInferenceCachedInputTokens(metrics);
+    if (input === undefined || cached === undefined || cached > input)
         return undefined;
-    return Math.max(0, input - (modelInferenceCachedInputTokens(metrics) ?? 0));
+    return input - cached;
+}
+export function modelInferenceCacheReadRatio(metrics) {
+    const input = modelInferenceInputTokens(metrics);
+    const cached = modelInferenceCachedInputTokens(metrics);
+    if (input === undefined || input === 0 || cached === undefined || cached > input)
+        return undefined;
+    return cached / input;
 }
 function tokenCount(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
 }
+export function compareInferenceCompletion(left, right) {
+    const time = Date.parse(left.completedAt ?? "") - Date.parse(right.completedAt ?? "");
+    if (Number.isFinite(time) && time !== 0)
+        return time;
+    if (left.completedSequence !== undefined && right.completedSequence !== undefined) {
+        return left.completedSequence - right.completedSequence;
+    }
+    return 0;
+}

package/dist/shared/trace-event-projection.js

@@ -4,6 +4,8 @@ import { attachAsyncAgentRunNode, isRunStartToolNode } from "./trace-async-agent
 import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
 import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subagent-links.js";
 import { qualifiedToolNodeId } from "./trace-tool-identity.js";
+import { observeCacheUsage } from "./cache-observability.js";
+import { compareInferenceCompletion } from "./model-inference-metrics.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
     if (payload.type === "assistant_usage") {
@@ -538,19 +540,35 @@ export function latestTraceStreamId(events, initial) {
 }
 function attachModelInferenceToLatestOutput(nodes, byId, event, storedEvent) {
     const eventId = event.eventId;
-    const candidates = flattenTraceNodes(nodes)
-        .filter((node) => node.eventId === eventId && traceNodeStartedBeforeInference(node, storedEvent) && (node.type === "assistant.message"
+    const flattened = flattenTraceNodes(nodes);
+    const id = event.inferenceId
+        ? `${eventId ?? storedEvent.piboSessionId}:inference:${event.inferenceId}`
+        : eventId ? `${eventId}:usage:${event.usageIndex ?? 0}` : storedEvent.id;
+    const candidates = flattened
+        .filter((node) => node.eventId === eventId && (event.inferenceTarget || traceNodeStartedBeforeInference(node, storedEvent)) && (node.type === "assistant.message"
         || node.type === "model.reasoning"
         || node.type === "tool.call"
         || node.type === "agent.delegation"))
         .sort(compareTraceNodes);
-    const target = candidates.at(-1) ?? (eventId ? byId.get(messageTurnNodeId(eventId)) : undefined);
+    const anchor = event.inferenceTarget;
+    const turnNode = eventId ? byId.get(messageTurnNodeId(eventId)) : undefined;
+    const anchoredTarget = anchor
+        ? (anchor.type === "tool"
+            ? candidates.find((node) => node.toolCallId === anchor.toolCallId)
+            : anchor.type === "assistant"
+                ? candidates.find((node) => node.stableKey === `assistant:${eventId}:assistant:${anchor.assistantIndex}`)
+                : turnNode) ?? turnNode
+        : candidates.at(-1) ?? turnNode;
+    // A repeated provider receipt updates its original inference instead of moving
+    // the usage record to whichever output happened to render last.
+    const target = flattened.find((node) => node.modelInferences?.some((item) => item.id === id)) ?? anchoredTarget;
     if (!target)
         return;
-    const id = eventId ? `${eventId}:usage:${event.usageIndex ?? 0}` : storedEvent.id;
+    const existingRecord = target.modelInferences?.find((item) => item.id === id);
     const record = {
         id,
-        completedAt: storedEvent.createdAt,
+        completedAt: existingRecord?.completedAt ?? storedEvent.createdAt,
+        completedSequence: existingRecord?.completedSequence ?? storedEvent.eventSequence ?? storedEvent.streamId,
         metrics: {
             ...(event.inputTokens === undefined ? {} : { inputTokens: event.inputTokens }),
             ...(event.outputTokens === undefined ? {} : { outputTokens: event.outputTokens }),
@@ -561,7 +579,27 @@ function attachModelInferenceToLatestOutput(nodes, byId, event, storedEvent) {
             ...(event.costUsd === undefined ? {} : { costUsd: event.costUsd }),
         },
     };
-    target.modelInferences = [...(target.modelInferences ?? []).filter((item) => item.id !== id), record];
+    const currentAt = Date.parse(record.completedAt ?? "");
+    let previous;
+    for (const node of flattened) {
+        for (const item of node.modelInferences ?? []) {
+            if (item.id !== id && compareInferenceCompletion(item, record) < 0
+                && (!previous || compareInferenceCompletion(item, previous) > 0)) {
+                previous = item;
+            }
+        }
+    }
+    const compactionBetween = previous !== undefined && Number.isFinite(currentAt) && flattened.some((node) => {
+        if (node.type !== "execution.compaction")
+            return false;
+        const boundary = {
+            completedAt: node.startedAt ?? node.completedAt,
+            completedSequence: node.orderKey?.eventSequence ?? node.orderKey?.streamId,
+        };
+        return compareInferenceCompletion(boundary, previous) > 0 && compareInferenceCompletion(boundary, record) <= 0;
+    });
+    record.cacheObservation = observeCacheUsage(record, previous, { compactionBetween });
+    target.modelInferences = [...(target.modelInferences ?? []).filter((item) => item.id !== id), record].sort(compareInferenceCompletion);
 }
 function traceNodeStartedBeforeInference(node, storedEvent) {
     const inferenceRenderSequence = storedEvent.renderSequence;

package/dist/web/channel.js

@@ -191,16 +191,31 @@ function createGatewayRuntimeStatuses(channelContext) {
         }
     });
 }
-function createGatewayStatusResponse(channelContext, options, generation) {
+async function createGatewayStatusResponse(channelContext, options, generation) {
     const mode = gatewayMode(options);
+    const appStatuses = {};
+    for (const app of channelContext.getWebApps()) {
+        if (!app.gatewayStatus)
+            continue;
+        try {
+            Object.assign(appStatuses, await app.gatewayStatus());
+        }
+        catch (error) {
+            appStatuses[`${app.name}Status`] = { status: "ambiguous", error: error instanceof Error ? error.message : "Status unavailable" };
+        }
+    }
+    const durable = appStatuses.durableMessageQueue;
     return responseJson({
-        status: "ok",
+        status: durable?.status === "degraded" || durable?.status === "ambiguous" ? "degraded" : "ok",
         mode,
         generation,
-        health: { status: "ok", mode },
+        health: { status: durable?.status === "degraded" || durable?.status === "ambiguous" ? "degraded" : "ok", mode },
+        runtimeQueue: { layer: "runtime-session", statuses: createGatewayRuntimeStatuses(channelContext) },
         runtimeStatuses: createGatewayRuntimeStatuses(channelContext),
         ...(channelContext.getRuntimeCapacityStatus ? { runtimeCapacity: channelContext.getRuntimeCapacityStatus() } : {}),
+        ...(channelContext.getRunJobReliabilityStatus ? { reliability: channelContext.getRunJobReliabilityStatus() } : {}),
         activeRuns: collectActiveRuns(channelContext),
+        ...appStatuses,
     });
 }
 function createCanonicalRedirect(request, canonicalBaseURL) {
@@ -218,6 +233,68 @@ function createCanonicalRedirect(request, canonicalBaseURL) {
 function isEventStreamResponse(response) {
     return response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream") === true;
 }
+function responseCanStart(response) {
+    return !response.destroyed && !response.writableEnded && !response.writableFinished && !response.headersSent;
+}
+function responseState(response) {
+    return [
+        `destroyed=${response.destroyed}`,
+        `writableEnded=${response.writableEnded}`,
+        `writableFinished=${response.writableFinished}`,
+        `headersSent=${response.headersSent}`,
+    ].join(",");
+}
+function requestPath(request) {
+    return (request.url ?? "/").split(/[?#]/, 1)[0].slice(0, 256).replace(/[\r\n]/g, "_");
+}
+function errorIdentity(error) {
+    try {
+        if (!(error instanceof Error))
+            return typeof error;
+        const rawName = typeof error.name === "string" ? error.name : "Error";
+        const name = rawName.replace(/[^A-Za-z0-9_.-]/g, "").slice(0, 64) || "Error";
+        const code = "code" in error && typeof error.code === "string" ? error.code.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64) : undefined;
+        return code ? `${name}:${code}` : name;
+    }
+    catch {
+        return "Error";
+    }
+}
+function logHttpBoundaryFailure(phase, request, error, response) {
+    try {
+        const method = (request.method ?? "UNKNOWN").replace(/[^A-Z]/gi, "").slice(0, 16) || "UNKNOWN";
+        const state = response ? ` response={${responseState(response)}}` : "";
+        console.error(`[web-host] contained ${phase} failure method=${method} path=${requestPath(request)} error=${errorIdentity(error)}${state}`);
+    }
+    catch {
+        // Diagnostics are best-effort and must never reopen the request rejection path.
+    }
+}
+function terminateResponse(response, error) {
+    if (response.destroyed || response.writableEnded || response.writableFinished)
+        return;
+    try {
+        response.destroy(error instanceof Error ? error : undefined);
+    }
+    catch {
+        // A broken response implementation must not escape the request boundary.
+    }
+}
+function endUpgradeSocket(socket, statusLine) {
+    if (socket.destroyed)
+        return;
+    try {
+        socket.end(statusLine);
+    }
+    catch {
+        try {
+            socket.destroy();
+        }
+        catch {
+            // A broken socket implementation must not escape the upgrade boundary.
+        }
+    }
+}
 async function waitForServerClose(closePromise, timeoutMs) {
     return await new Promise((resolve, reject) => {
         let settled = false;
@@ -323,7 +400,7 @@ export function createWebHostChannel(options = {}) {
                 return;
             }
             if (url.pathname === "/gateway/status") {
-                await sendResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options, generation));
+                await sendResponse(nodeResponse, await createGatewayStatusResponse(requireContext(), options, generation));
                 return;
             }
             if (url.pathname.startsWith("/api/auth/")) {
@@ -360,8 +437,18 @@ export function createWebHostChannel(options = {}) {
         }
         catch (error) {
             const status = error instanceof PiboAuthError || error instanceof PiboWebHttpError ? error.statusCode : 500;
-            if (!nodeResponse.destroyed) {
-                await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+            logHttpBoundaryFailure("request", nodeRequest, error, nodeResponse);
+            if (responseCanStart(nodeResponse)) {
+                try {
+                    await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+                }
+                catch (responseError) {
+                    logHttpBoundaryFailure("error-response", nodeRequest, responseError, nodeResponse);
+                    terminateResponse(nodeResponse, responseError);
+                }
+            }
+            else {
+                terminateResponse(nodeResponse, error);
             }
         }
         finally {
@@ -384,10 +471,9 @@ export function createWebHostChannel(options = {}) {
             await app.handleUpgrade(nodeRequest, socket, head, createAppContext(ctx), requestURL);
         }
         catch (error) {
-            if (!socket.destroyed) {
-                const unauthorized = error instanceof PiboAuthError || error instanceof PiboWebHttpError;
-                socket.end(`HTTP/1.1 ${unauthorized ? 401 : 502} ${unauthorized ? "Unauthorized" : "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
-            }
+            logHttpBoundaryFailure("upgrade", nodeRequest, error);
+            const unauthorized = error instanceof PiboAuthError || error instanceof PiboWebHttpError;
+            endUpgradeSocket(socket, `HTTP/1.1 ${unauthorized ? 401 : 502} ${unauthorized ? "Unauthorized" : "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
         }
     };
     return {
@@ -405,10 +491,26 @@ export function createWebHostChannel(options = {}) {
             for (const app of channelContext.getWebApps())
                 await app.initialize?.(createAppContext(channelContext));
             server = createServer((request, response) => {
-                void handleRequest(request, response);
+                void handleRequest(request, response).catch((error) => {
+                    try {
+                        logHttpBoundaryFailure("request-terminal", request, error, response);
+                        terminateResponse(response, error);
+                    }
+                    catch {
+                        // The terminal request boundary itself is intentionally nonthrowing.
+                    }
+                });
             });
             server.on("upgrade", (request, socket, head) => {
-                void handleUpgrade(request, socket, head);
+                void handleUpgrade(request, socket, head).catch((error) => {
+                    try {
+                        logHttpBoundaryFailure("upgrade-terminal", request, error);
+                        endUpgradeSocket(socket);
+                    }
+                    catch {
+                        // The terminal upgrade boundary itself is intentionally nonthrowing.
+                    }
+                });
             });
             server.on("connection", (socket) => {
                 sockets.add(socket);

package/dist/web/http.js

@@ -78,74 +78,136 @@ export async function nodeRequestToWebRequest(request, baseURL, signal) {
     });
 }
 export async function sendWebResponse(response, webResponse, options = {}) {
+    assertResponseCanStart(response);
     const headers = responseHeaders(webResponse);
     const compressEncoding = preferredResponseEncoding(response.req?.headers["accept-encoding"], webResponse);
-    if (compressEncoding && webResponse.body) {
-        const body = await readResponseBody(webResponse);
-        if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            const compressionStartedAt = performance.now();
-            const compressed = gzipSync(body, { level: 1 });
-            appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
-            headers["content-encoding"] = compressEncoding;
-            headers["content-length"] = String(compressed.length);
-            headers.vary = appendVary(headers.vary, "accept-encoding");
+    let reader = webResponse.body?.getReader();
+    let wroteHeaders = false;
+    let clientClosed = false;
+    const cancelReader = () => {
+        if (reader)
+            void reader.cancel().catch(() => undefined);
+    };
+    const close = () => {
+        clientClosed = true;
+        cancelReader();
+    };
+    const abort = () => {
+        cancelReader();
+        try {
+            if (!response.destroyed && !response.writableEnded)
+                response.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+        try {
+            response.socket?.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+    };
+    if (reader) {
+        response.once("close", close);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+    }
+    try {
+        if (compressEncoding && reader) {
+            const body = await readResponseBody(reader);
+            if (clientClosed || options.signal?.aborted || response.destroyed || response.writableEnded || response.writableFinished)
+                return;
+            assertResponseCanStart(response);
+            if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                const compressionStartedAt = performance.now();
+                const compressed = gzipSync(body, { level: 1 });
+                appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
+                headers["content-encoding"] = compressEncoding;
+                headers["content-length"] = String(compressed.length);
+                headers.vary = appendVary(headers.vary, "accept-encoding");
+                response.writeHead(webResponse.status, headers);
+                wroteHeaders = true;
+                response.end(compressed);
+                return;
+            }
+            if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
+            }
             response.writeHead(webResponse.status, headers);
-            response.end(compressed);
+            wroteHeaders = true;
+            response.end(body);
             return;
         }
-        if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
-        }
         response.writeHead(webResponse.status, headers);
-        response.end(body);
-        return;
-    }
-    response.writeHead(webResponse.status, headers);
-    if (!webResponse.body) {
-        response.end();
-        return;
-    }
-    const reader = webResponse.body.getReader();
-    const cancel = () => {
-        void reader.cancel().catch(() => undefined);
-    };
-    const abort = () => {
-        const socket = response.socket;
-        void reader.cancel().catch(() => undefined);
-        if (!response.writableEnded)
+        wroteHeaders = true;
+        if (!reader) {
             response.end();
-        socket?.end();
-    };
-    response.once("close", cancel);
-    options.signal?.addEventListener("abort", abort, { once: true });
-    if (options.signal?.aborted)
-        abort();
-    try {
+            return;
+        }
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
             const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
             for (let offset = 0; offset < bytes.length; offset += 64 * 1024) {
-                if (response.destroyed || response.writableEnded)
+                if (response.destroyed || response.writableEnded || response.writableFinished) {
+                    cancelReader();
                     return;
+                }
                 if (!response.write(bytes.subarray(offset, offset + 64 * 1024))) {
                     const drained = await waitForResponseDrain(response, (webResponse.headers.get("content-type") ?? "").startsWith("text/event-stream") ? 5000 : undefined, options.signal);
                     if (!drained) {
-                        void reader.cancel().catch(() => undefined);
-                        if (!response.destroyed)
-                            response.destroy();
+                        cancelReader();
+                        tryDestroyResponse(response);
                         return;
                     }
                 }
             }
         }
-        if (!response.writableEnded)
+        if (!response.destroyed && !response.writableEnded && !response.writableFinished)
             response.end();
     }
+    catch (error) {
+        cancelReader();
+        if (clientClosed || response.destroyed || response.writableEnded || response.writableFinished)
+            return;
+        if (wroteHeaders || response.headersSent)
+            tryDestroyResponse(response, error);
+        throw error;
+    }
     finally {
-        response.off("close", cancel);
+        response.off("close", close);
         options.signal?.removeEventListener("abort", abort);
+        if (reader) {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // Cancellation/read settlement owns the lock until the pending read resolves.
+            }
+        }
+    }
+}
+function assertResponseCanStart(response) {
+    if (response.destroyed)
+        throw new Error("HTTP response is destroyed");
+    if (response.writableEnded)
+        throw new Error("HTTP response has ended");
+    if (response.writableFinished)
+        throw new Error("HTTP response has finished");
+    if (response.headersSent)
+        throw new Error("HTTP response headers were already sent");
+}
+function tryDestroyResponse(response, error) {
+    if (response.destroyed)
+        return;
+    try {
+        response.destroy(error instanceof Error ? error : undefined);
+    }
+    catch {
+        // The request boundary is best-effort once the response implementation itself fails.
     }
 }
 function appendServerTimingHeader(headers, value) {
@@ -198,9 +260,8 @@ function responseCanBeCompressed(webResponse) {
     const contentType = webResponse.headers.get("content-type") ?? "";
     return /^application\/json\b/.test(contentType);
 }
-async function readResponseBody(webResponse) {
+async function readResponseBody(reader) {
     const chunks = [];
-    const reader = webResponse.body.getReader();
     while (true) {
         const { done, value } = await reader.read();
         if (done)

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.5.0",
+      "version": "3.6.0",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",