@pasko70/pibo 3.4.3 → 3.5.0

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

@@ -0,0 +1,23 @@
+export function modelInferenceInputTokens(metrics) {
+    const total = tokenCount(metrics?.totalTokens);
+    const output = tokenCount(metrics?.outputTokens);
+    if (total !== undefined && output !== undefined)
+        return Math.max(0, total - output);
+    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);
+}
+export function modelInferenceUncachedInputTokens(metrics) {
+    const input = modelInferenceInputTokens(metrics);
+    if (input === undefined)
+        return undefined;
+    return Math.max(0, input - (modelInferenceCachedInputTokens(metrics) ?? 0));
+}
+function tokenCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}

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

@@ -6,6 +6,10 @@ import { findLikelyTraceChildSession, isSubagentToolName, } from "./trace-subage
 import { qualifiedToolNodeId } from "./trace-tool-identity.js";
 export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent, childByParent, linkedChildByToolCallId, historyCoverage, openTranscriptEventIds, sessionStatus) {
     const payload = storedEvent.payload;
+    if (payload.type === "assistant_usage") {
+        attachModelInferenceToLatestOutput(nodes, byId, payload, storedEvent);
+        return;
+    }
     if (payload.type === "message_started" && payload.source === "user" && payload.eventId) {
         const persistedUser = flattenTraceNodes([...nodes]).find((node) => node.type === "user.message"
             && isPersistedHistorySource(node.source)
@@ -42,6 +46,7 @@ export function applySingleEventToNodes(nodes, byId, piboSessionId, storedEvent,
     }
     if (payload.type === "assistant_message") {
         const node = assistantMessageNodeFromEvent(piboSessionId, payload, storedEvent.createdAt, storedEvent.eventSequence, storedEvent.streamId, storedEvent.streamFrameIndex, storedEvent.traceSource, storedEvent.id);
+        applyStoredPayloadRef(node, payload, storedEvent.storedPayloadRef);
         const existing = byId.get(node.id) ?? findMatchingContentNode(byId, node);
         if (existing) {
             mergeAssistantMessageEvent(existing, node);
@@ -153,8 +158,12 @@ function applyRenderSequenceToHistoryNode(byId, storedEvent, event) {
             && typeof event.toolCallId === "string"
             && node.toolCallId === event.toolCallId
             && (!eventId || !node.eventId || node.eventId === eventId)));
-    if (target)
-        applyRenderSequence(target, storedEvent, event);
+    if (!target)
+        return;
+    applyRenderSequence(target, storedEvent, event);
+    if (event.type === "tool_execution_finished" && event.toolMetrics) {
+        target.toolMetrics = event.toolMetrics;
+    }
 }
 function applyRenderSequence(node, storedEvent, event) {
     const renderSequence = storedEvent.renderSequence ?? event.renderSequence;
@@ -171,6 +180,9 @@ function applyRenderSequence(node, storedEvent, event) {
 function applyStoredPayloadRef(node, event, storedPayloadRef) {
     if (!storedPayloadRef)
         return;
+    if (event.type === "assistant_message" || event.type === "thinking_finished") {
+        node.payloadRefs = { ...node.payloadRefs, [storedPayloadRef.payloadKind ?? "output"]: storedPayloadRef };
+    }
     if (event.type === "tool_call" || event.type === "tool_execution_started") {
         node.payloadRefs = { ...node.payloadRefs, input: storedPayloadRef };
     }
@@ -524,6 +536,47 @@ export function latestTraceStreamId(events, initial) {
     }
     return latest;
 }
+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"
+        || 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);
+    if (!target)
+        return;
+    const id = eventId ? `${eventId}:usage:${event.usageIndex ?? 0}` : storedEvent.id;
+    const record = {
+        id,
+        completedAt: storedEvent.createdAt,
+        metrics: {
+            ...(event.inputTokens === undefined ? {} : { inputTokens: event.inputTokens }),
+            ...(event.outputTokens === undefined ? {} : { outputTokens: event.outputTokens }),
+            ...(event.cacheReadTokens === undefined ? {} : { cacheReadTokens: event.cacheReadTokens }),
+            ...(event.cacheWriteTokens === undefined ? {} : { cacheWriteTokens: event.cacheWriteTokens }),
+            ...(event.reasoningTokens === undefined ? {} : { reasoningTokens: event.reasoningTokens }),
+            totalTokens: event.totalTokens,
+            ...(event.costUsd === undefined ? {} : { costUsd: event.costUsd }),
+        },
+    };
+    target.modelInferences = [...(target.modelInferences ?? []).filter((item) => item.id !== id), record];
+}
+function traceNodeStartedBeforeInference(node, storedEvent) {
+    const inferenceRenderSequence = storedEvent.renderSequence;
+    const nodeRenderSequence = node.orderKey?.renderSequence;
+    if (inferenceRenderSequence !== undefined && nodeRenderSequence !== undefined) {
+        return nodeRenderSequence <= inferenceRenderSequence;
+    }
+    const inferenceSequence = storedEvent.eventSequence ?? storedEvent.streamId;
+    const nodeSequence = node.orderKey?.eventSequence ?? node.orderKey?.streamId;
+    if (inferenceSequence !== undefined && nodeSequence !== undefined)
+        return nodeSequence <= inferenceSequence;
+    const inferenceTime = Date.parse(storedEvent.createdAt);
+    const nodeTime = Date.parse(node.startedAt ?? node.completedAt ?? "");
+    return !Number.isFinite(inferenceTime) || !Number.isFinite(nodeTime) || nodeTime <= inferenceTime;
+}
 // ── event → node helpers ─────────────────────────────────────────
 function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByToolCallId, sessionStatus, createdAt, eventSequence, streamId, streamFrameIndex, traceSource, storedInstanceId) {
     const eventId = "eventId" in event && typeof event.eventId === "string" ? event.eventId : undefined;
@@ -562,6 +615,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 type: "user.message",
                 title: "User Message",
                 status: isOptimisticUserMessageEvent(event) ? "running" : "done",
+                messageDeliveryState: isOptimisticUserMessageEvent(event) ? "sending" : undefined,
                 summary: event.text,
                 output: event.text,
             };
@@ -711,6 +765,7 @@ function traceNodeFromEvent(piboSessionId, event, childByParent, linkedChildByTo
                 input: { reason: event.reason },
                 output: event.result,
                 error: event.errorMessage,
+                compactionStats: event.compactionStats,
                 stableKey: `compaction:${eventInstanceKey}`,
             };
         }
@@ -768,6 +823,7 @@ function findMatchingContentNode(byId, update) {
     return [...byId.values()].find((candidate) => candidate.type === update.type && candidate.stableKey === update.stableKey);
 }
 function mergeAssistantMessageEvent(target, update) {
+    target.payloadRefs = { ...target.payloadRefs, ...update.payloadRefs };
     target.status = update.status;
     target.summary = update.summary ?? target.summary;
     target.output = update.output ?? target.output;
@@ -1163,6 +1219,7 @@ function mergeCompactionEvent(target, update) {
     target.input = update.input ?? target.input;
     target.output = update.output ?? target.output;
     target.error = update.error ?? target.error;
+    target.compactionStats = update.compactionStats ?? target.compactionStats;
     target.completedAt = update.completedAt ?? target.completedAt;
 }
 function hasVisibleText(value) {

package/dist/shared/trace-history.js

@@ -710,6 +710,7 @@ function createUserMessageNode(piboSessionId, entry, entryIndex, timing, fallbac
         startedAt: entry.createdAt,
         summary: text,
         output: text,
+        payloadRefs: historyContentPayloadRef(entry),
         error: entry.error,
         source,
         stableKey: eventIdentity ?? historyEntryStableKey(entry),
@@ -902,6 +903,7 @@ function createAssistantMessageNode(input) {
         completedAt: input.completedAt,
         summary: input.text,
         output: input.text,
+        payloadRefs: historyContentPayloadRef(input.entry),
         error: input.error,
         source,
         stableKey: eventIdentity ? `assistant:${eventIdentity}` : `${historyEntryStableKey(input.entry)}:response:${input.contentPartIndex}`,
@@ -909,6 +911,13 @@ function createAssistantMessageNode(input) {
         children: input.children ?? [],
     };
 }
+/** Preserve a stored full body when the bounded history page contains its preview. */
+function historyContentPayloadRef(entry) {
+    const ref = entry.source === "product" ? entry.metadata?.tracePayloadRef : undefined;
+    if (!ref || typeof ref !== "object" || Array.isArray(ref) || typeof ref.ref !== "string" || typeof ref.byteLength !== "number" || typeof ref.preview !== "string")
+        return undefined;
+    return { output: ref };
+}
 function historyMessageParts(entry) {
     return typeof entry.content === "string" ? [{ type: "text", text: entry.content }] : [...entry.content];
 }

package/dist/shared/trace-live-reducer.js

@@ -165,6 +165,7 @@ function makeStored(streamEvent, piboSessionId, type, payload, nextSequence, now
         streamId: typeof streamEvent.streamId === "number" ? streamEvent.streamId : undefined,
         streamFrameIndex,
         traceSource: "live",
+        storedPayloadRef: streamEvent.storedPayloadRef,
         eventId: typeof positionedPayload.eventId === "string" ? positionedPayload.eventId : undefined,
         type,
         createdAt: streamEventCreatedAt(streamEvent) ?? now(),

package/dist/shared/trace-patch-nodes.js

@@ -64,6 +64,7 @@ function traceNodeShallowEqual(left, right) {
         left.toolMetrics?.inputTokens === right.toolMetrics?.inputTokens &&
         left.toolMetrics?.outputTokens === right.toolMetrics?.outputTokens &&
         left.toolMetrics?.tokenBasis === right.toolMetrics?.tokenBasis &&
+        modelInferenceRecordsEqual(left.modelInferences, right.modelInferences) &&
         left.summary === right.summary &&
         left.input === right.input &&
         left.output === right.output &&
@@ -73,6 +74,24 @@ function traceNodeShallowEqual(left, right) {
         left.stableKey === right.stableKey &&
         traceOrderKeyEqual(left.orderKey, right.orderKey));
 }
+function modelInferenceRecordsEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right || left.length !== right.length)
+        return false;
+    return left.every((item, index) => {
+        const other = right[index];
+        return item.id === other?.id
+            && item.completedAt === other.completedAt
+            && item.metrics.inputTokens === other.metrics.inputTokens
+            && item.metrics.outputTokens === other.metrics.outputTokens
+            && item.metrics.cacheReadTokens === other.metrics.cacheReadTokens
+            && item.metrics.cacheWriteTokens === other.metrics.cacheWriteTokens
+            && item.metrics.reasoningTokens === other.metrics.reasoningTokens
+            && item.metrics.totalTokens === other.metrics.totalTokens
+            && item.metrics.costUsd === other.metrics.costUsd;
+    });
+}
 function traceOrderKeyEqual(left, right) {
     if (left === right)
         return true;

package/dist/web/channel.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { PiboAuthError } from "../auth/types.js";
 import { handleSimpleAgentApiRequest } from "../api/simple-agent-api.js";
@@ -190,13 +191,15 @@ function createGatewayRuntimeStatuses(channelContext) {
         }
     });
 }
-function createGatewayStatusResponse(channelContext, options) {
+function createGatewayStatusResponse(channelContext, options, generation) {
     const mode = gatewayMode(options);
     return responseJson({
         status: "ok",
         mode,
+        generation,
         health: { status: "ok", mode },
         runtimeStatuses: createGatewayRuntimeStatuses(channelContext),
+        ...(channelContext.getRuntimeCapacityStatus ? { runtimeCapacity: channelContext.getRuntimeCapacityStatus() } : {}),
         activeRuns: collectActiveRuns(channelContext),
     });
 }
@@ -238,6 +241,7 @@ async function waitForServerClose(closePromise, timeoutMs) {
     });
 }
 export function createWebHostChannel(options = {}) {
+    const generation = randomUUID();
     const host = options.host ?? DEFAULT_WEB_CHANNEL_HOST;
     const port = options.port ?? DEFAULT_WEB_CHANNEL_PORT;
     const shutdownDrainTimeoutMs = options.shutdownDrainTimeoutMs ?? DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS;
@@ -319,7 +323,7 @@ export function createWebHostChannel(options = {}) {
                 return;
             }
             if (url.pathname === "/gateway/status") {
-                await sendResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options));
+                await sendResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options, generation));
                 return;
             }
             if (url.pathname.startsWith("/api/auth/")) {
@@ -398,6 +402,8 @@ export function createWebHostChannel(options = {}) {
                 return;
             shuttingDown = false;
             context = channelContext;
+            for (const app of channelContext.getWebApps())
+                await app.initialize?.(createAppContext(channelContext));
             server = createServer((request, response) => {
                 void handleRequest(request, response);
             });

package/dist/web/http.js

@@ -107,11 +107,11 @@ export async function sendWebResponse(response, webResponse, options = {}) {
     }
     const reader = webResponse.body.getReader();
     const cancel = () => {
-        void reader.cancel();
+        void reader.cancel().catch(() => undefined);
     };
     const abort = () => {
         const socket = response.socket;
-        void reader.cancel();
+        void reader.cancel().catch(() => undefined);
         if (!response.writableEnded)
             response.end();
         socket?.end();
@@ -125,7 +125,20 @@ export async function sendWebResponse(response, webResponse, options = {}) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            response.write(Buffer.from(value));
+            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)
+                    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();
+                        return;
+                    }
+                }
+            }
         }
         if (!response.writableEnded)
             response.end();
@@ -206,3 +219,23 @@ function appendVary(existing, value) {
 function appendServerTiming(existing, value) {
     return existing ? `${existing}, ${value}` : value;
 }
+/** Honor socket pressure before pulling another application frame. */
+function waitForResponseDrain(response, maximumAgeMs, signal) {
+    if (response.destroyed || response.writableEnded || signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let timer;
+        const finish = (ready) => { if (timer)
+            clearTimeout(timer); response.off("drain", drain); response.off("close", close); response.off("error", close); signal?.removeEventListener("abort", close); resolve(ready); };
+        const drain = () => finish(true);
+        const close = () => finish(false);
+        response.once("drain", drain);
+        response.once("close", close);
+        response.once("error", close);
+        signal?.addEventListener("abort", close, { once: true });
+        if (maximumAgeMs !== undefined) {
+            timer = setTimeout(close, maximumAgeMs);
+            timer.unref();
+        }
+    });
+}

package/npm-shrinkwrap.json

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

package/package.json

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