@pasko70/pibo 1.11.4 → 1.12.1

package/dist/shared/trace-transcript.js

@@ -3,29 +3,37 @@ import { attachAsyncAgentRunNode, reconcileAsyncAgentRunStatuses } from "./trace
 import { sortTraceNodes } from "./trace-nodes.js";
 import { createRunNotificationNode, parseRunNotificationText } from "./trace-run-notifications.js";
 import { isSubagentToolName } from "./trace-subagent-links.js";
-export function projectTranscriptEntries(entries, sessionStatus, openTranscriptEventIds) {
+import { assistantMessageNodeId, thinkingNodeId } from "./trace-event-projection.js";
+export function projectTranscriptEntries(entries, sessionStatus, openTranscriptEventIds, turnTimings = []) {
     if (sessionStatus !== "running" || openTranscriptEventIds.size === 0)
         return entries;
+    const userTimingAssignments = assignTranscriptUserTimings(entries, turnTimings);
     let lastUserMessageIndex = -1;
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
+    let lastUserEventId;
+    for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
-        if (entry.type === "message" && messageRole(entry) === "user") {
-            lastUserMessageIndex = index;
-            break;
-        }
+        if (entry.type !== "message" || messageRole(entry) !== "user")
+            continue;
+        lastUserMessageIndex = index;
+        lastUserEventId = openTranscriptEventIds.has(entry.id)
+            ? entry.id
+            : userTimingAssignments.get(index)?.eventId;
     }
-    return lastUserMessageIndex === -1 ? entries : entries.slice(0, lastUserMessageIndex);
+    return lastUserMessageIndex !== -1 && lastUserEventId && openTranscriptEventIds.has(lastUserEventId)
+        ? entries.slice(0, lastUserMessageIndex)
+        : entries;
 }
 export function traceNodesFromEntries(piboSessionId, entries, turnTimings = []) {
     const nodes = [];
     const turnTimingAssignments = assignTranscriptTurnTimings(entries, turnTimings);
+    const userTimingAssignments = assignTranscriptUserTimings(entries, turnTimings);
     let assistantTurnIndex = 0;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry.type === "message") {
             const role = messageRole(entry);
             if (role === "user") {
-                nodes.push(createUserMessageNode(piboSessionId, entry, messageContent(entry), index));
+                nodes.push(createUserMessageNode(piboSessionId, entry, messageContent(entry), index, userTimingAssignments.get(index)));
             }
             else if (role === "assistant" || role === "toolResult") {
                 const turn = collectAssistantTurn(entries, index);
@@ -70,9 +78,10 @@ function messageParts(entry) {
         return [{ type: "text", text: content }];
     return Array.isArray(content) ? content : [];
 }
-function assignTranscriptTurnTimings(entries, turnTimings) {
-    const transcriptTurns = [];
+function collectTranscriptTurnTimingTargets(entries) {
+    const targets = [];
     let latestUserText;
+    let latestUserEntryIndex;
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (entry.type !== "message")
@@ -80,6 +89,7 @@ function assignTranscriptTurnTimings(entries, turnTimings) {
         const role = messageRole(entry);
         if (role === "user") {
             latestUserText = normalizedPrompt(extractText(messageContent(entry)));
+            latestUserEntryIndex = index;
             continue;
         }
         if (role !== "assistant" && role !== "toolResult")
@@ -87,12 +97,22 @@ function assignTranscriptTurnTimings(entries, turnTimings) {
         const turn = collectAssistantTurn(entries, index);
         const lastAssistant = [...turn.entries].reverse().find(({ entry: turnEntry }) => messageRole(turnEntry) === "assistant");
         if (lastAssistant) {
-            transcriptTurns.push({ prompt: latestUserText, assistantAt: parsedTimestamp(lastAssistant.entry.timestamp) });
+            targets.push({
+                prompt: latestUserText,
+                userEntryIndex: latestUserEntryIndex,
+                assistantAt: parsedTimestamp(lastAssistant.entry.timestamp),
+                settled: isSettledAssistantEntry(lastAssistant.entry),
+            });
         }
         index = turn.nextIndex - 1;
     }
+    return targets;
+}
+function assignTranscriptTurnTimings(entries, turnTimings) {
+    const messageTurnTimings = turnTimings.filter((timing) => timing.userMessageType !== "message_steered");
+    const transcriptTurns = collectTranscriptTurnTimingTargets(entries);
     const assignments = Array(transcriptTurns.length).fill(undefined);
-    let timingCursor = turnTimings.length - 1;
+    let timingCursor = messageTurnTimings.length - 1;
     for (let turnIndex = transcriptTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
         const transcriptTurn = transcriptTurns[turnIndex];
         if (!transcriptTurn?.prompt)
@@ -100,7 +120,7 @@ function assignTranscriptTurnTimings(entries, turnTimings) {
         let matchedIndex;
         let matchedDistance = Number.POSITIVE_INFINITY;
         for (let timingIndex = timingCursor; timingIndex >= 0; timingIndex -= 1) {
-            const timing = turnTimings[timingIndex];
+            const timing = messageTurnTimings[timingIndex];
             if (normalizedPrompt(timing?.userText) !== transcriptTurn.prompt)
                 continue;
             const completedAt = parsedTimestamp(timing?.completedAt);
@@ -114,11 +134,133 @@ function assignTranscriptTurnTimings(entries, turnTimings) {
         }
         if (matchedIndex === undefined)
             continue;
-        assignments[turnIndex] = turnTimings[matchedIndex];
+        assignments[turnIndex] = messageTurnTimings[matchedIndex];
         timingCursor = matchedIndex - 1;
     }
     return assignments;
 }
+function assignTranscriptUserTimings(entries, turnTimings) {
+    const users = [];
+    const userPositionByEntryIndex = new Map();
+    for (let entryIndex = 0; entryIndex < entries.length; entryIndex += 1) {
+        const entry = entries[entryIndex];
+        if (entry.type !== "message" || messageRole(entry) !== "user")
+            continue;
+        userPositionByEntryIndex.set(entryIndex, users.length);
+        users.push({
+            entryIndex,
+            entryId: entry.id,
+            prompt: normalizedPrompt(extractText(messageContent(entry))),
+        });
+    }
+    if (!users.length || !turnTimings.length)
+        return new Map();
+    const timingIndexByEventId = new Map(turnTimings.map((timing, timingIndex) => [timing.eventId, timingIndex]));
+    const anchorByUserPosition = new Map();
+    const assignedTimingIndexes = new Set();
+    for (let userPosition = 0; userPosition < users.length; userPosition += 1) {
+        const timingIndex = timingIndexByEventId.get(users[userPosition].entryId);
+        if (timingIndex === undefined || assignedTimingIndexes.has(timingIndex))
+            continue;
+        anchorByUserPosition.set(userPosition, timingIndex);
+        assignedTimingIndexes.add(timingIndex);
+    }
+    const transcriptTurns = collectTranscriptTurnTimingTargets(entries);
+    let timingUpperBound = turnTimings.length - 1;
+    for (let turnIndex = transcriptTurns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+        const transcriptTurn = transcriptTurns[turnIndex];
+        const userPosition = transcriptTurn?.userEntryIndex === undefined
+            ? undefined
+            : userPositionByEntryIndex.get(transcriptTurn.userEntryIndex);
+        if (!transcriptTurn?.prompt || userPosition === undefined)
+            continue;
+        const exactAnchor = anchorByUserPosition.get(userPosition);
+        if (exactAnchor !== undefined) {
+            timingUpperBound = Math.min(timingUpperBound, exactAnchor - 1);
+            continue;
+        }
+        let steeringTimingIndex;
+        for (let timingIndex = timingUpperBound; timingIndex >= 0; timingIndex -= 1) {
+            const timing = turnTimings[timingIndex];
+            if (assignedTimingIndexes.has(timingIndex) || timing.userMessageType !== "message_steered")
+                continue;
+            if (normalizedPrompt(timing.userText) !== transcriptTurn.prompt)
+                continue;
+            steeringTimingIndex = timingIndex;
+            break;
+        }
+        if (steeringTimingIndex !== undefined) {
+            anchorByUserPosition.set(userPosition, steeringTimingIndex);
+            assignedTimingIndexes.add(steeringTimingIndex);
+            timingUpperBound = steeringTimingIndex - 1;
+            continue;
+        }
+        if (!transcriptTurn.settled)
+            continue;
+        let matchedTimingIndex;
+        let matchedDistance = Number.POSITIVE_INFINITY;
+        for (let timingIndex = timingUpperBound; timingIndex >= 0; timingIndex -= 1) {
+            const timing = turnTimings[timingIndex];
+            if (assignedTimingIndexes.has(timingIndex) || timing.userMessageType === "message_steered" || !timing.completedAt)
+                continue;
+            if (normalizedPrompt(timing.userText) !== transcriptTurn.prompt)
+                continue;
+            const completedAt = parsedTimestamp(timing.completedAt);
+            const distance = completedAt === undefined || transcriptTurn.assistantAt === undefined
+                ? Number.POSITIVE_INFINITY
+                : Math.abs(completedAt - transcriptTurn.assistantAt);
+            if (matchedTimingIndex === undefined || distance < matchedDistance) {
+                matchedTimingIndex = timingIndex;
+                matchedDistance = distance;
+            }
+        }
+        if (matchedTimingIndex === undefined)
+            continue;
+        anchorByUserPosition.set(userPosition, matchedTimingIndex);
+        assignedTimingIndexes.add(matchedTimingIndex);
+        timingUpperBound = matchedTimingIndex - 1;
+    }
+    const assignments = new Map();
+    const anchors = [...anchorByUserPosition.entries()]
+        .map(([userPosition, timingIndex]) => ({ userPosition, timingIndex }))
+        .sort((left, right) => left.userPosition - right.userPosition);
+    for (const anchor of anchors) {
+        assignments.set(users[anchor.userPosition].entryIndex, turnTimings[anchor.timingIndex]);
+    }
+    const boundaries = [
+        { userPosition: -1, timingIndex: -1 },
+        ...anchors,
+        { userPosition: users.length, timingIndex: turnTimings.length },
+    ];
+    for (let boundaryIndex = 0; boundaryIndex < boundaries.length - 1; boundaryIndex += 1) {
+        const previous = boundaries[boundaryIndex];
+        const next = boundaries[boundaryIndex + 1];
+        let timingCursor = next.timingIndex - 1;
+        for (let userPosition = next.userPosition - 1; userPosition > previous.userPosition; userPosition -= 1) {
+            const user = users[userPosition];
+            if (assignments.has(user.entryIndex) || !user.prompt)
+                continue;
+            for (let timingIndex = timingCursor; timingIndex > previous.timingIndex; timingIndex -= 1) {
+                if (assignedTimingIndexes.has(timingIndex))
+                    continue;
+                const timing = turnTimings[timingIndex];
+                if (normalizedPrompt(timing.userText) !== user.prompt)
+                    continue;
+                assignments.set(user.entryIndex, timing);
+                assignedTimingIndexes.add(timingIndex);
+                timingCursor = timingIndex - 1;
+                break;
+            }
+        }
+    }
+    return assignments;
+}
+function isSettledAssistantEntry(entry) {
+    const message = entry.message;
+    if (message.stopReason === "toolUse" || message.stopReason === "tool_use")
+        return false;
+    return message.status !== "streaming" && message.status !== "in_progress";
+}
 function normalizedPrompt(value) {
     const normalized = value?.replace(/\s+/g, " ").trim();
     return normalized || undefined;
@@ -144,7 +286,7 @@ function collectAssistantTurn(entries, startIndex) {
     }
     return { entries: turnEntries, nextIndex: index };
 }
-function createUserMessageNode(piboSessionId, entry, content, entryIndex) {
+function createUserMessageNode(piboSessionId, entry, content, entryIndex, timing) {
     const text = extractText(content);
     const notification = parseRunNotificationText(text);
     if (notification) {
@@ -159,8 +301,10 @@ function createUserMessageNode(piboSessionId, entry, content, entryIndex) {
             notification,
         });
     }
+    const userMessageType = timing?.userMessageType ?? "message_queued";
+    const eventIdentity = timing ? `event:${userMessageType}:${timing.eventId}` : undefined;
     return {
-        id: `entry:${entry.id}`,
+        id: eventIdentity ?? `entry:${entry.id}`,
         entryId: entry.id,
         piboSessionId,
         type: "user.message",
@@ -170,7 +314,7 @@ function createUserMessageNode(piboSessionId, entry, content, entryIndex) {
         summary: text,
         output: text,
         source: "transcript",
-        stableKey: `entry:${entry.id}`,
+        stableKey: eventIdentity ?? `entry:${entry.id}`,
         orderKey: transcriptTraceOrder(entryIndex, 0, "user.message"),
         children: [],
     };
@@ -181,7 +325,8 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
         return [];
     const orderedNodes = [];
     const toolsByCallId = new Map();
-    let assistantIndex = 0;
+    let assistantPartOrdinal = 0;
+    let reasoningPartOrdinal = 0;
     for (const { entry, index: entryIndex } of entries) {
         if (messageRole(entry) === "toolResult") {
             mergePersistedToolResult(toolsByCallId, orderedNodes, entry, piboSessionId, entryIndex);
@@ -193,16 +338,28 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
         for (const [index, part] of messageParts(entry).entries()) {
             const typed = part;
             if (typed.type === "thinking" && typeof typed.thinking === "string" && hasVisibleText(typed.thinking)) {
-                orderedNodes.push(createReasoningNode(piboSessionId, entry, entryIndex, index, typed.thinking));
+                const thinkingIndex = timing?.reasoningIndices?.[reasoningPartOrdinal] ?? reasoningPartOrdinal;
+                orderedNodes.push(createReasoningNode({
+                    piboSessionId,
+                    entry,
+                    entryIndex,
+                    contentPartIndex: index,
+                    thinkingIndex,
+                    eventId: timing?.eventId,
+                    thinking: typed.thinking,
+                }));
+                reasoningPartOrdinal += 1;
             }
             else if (typed.type === "text" && typeof typed.text === "string" && typed.text !== "") {
                 if (!responseNode) {
+                    const assistantIndex = timing?.assistantIndices?.[assistantPartOrdinal] ?? assistantPartOrdinal;
                     responseNode = createAssistantMessageNode({
-                        id: `entry:${entry.id}:response`,
                         piboSessionId,
                         entry,
                         entryIndex,
                         contentPartIndex: index,
+                        assistantIndex,
+                        eventId: timing?.eventId,
                         status: responseStatus,
                         text: typed.text,
                         error: responseError,
@@ -225,9 +382,7 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
         if (responseNode) {
             responseNode.status = responseStatus;
             responseNode.error = responseError;
-            if (timing?.eventId)
-                responseNode.stableKey = `assistant:${timing.eventId}:assistant:${assistantIndex}`;
-            assistantIndex += 1;
+            assistantPartOrdinal += 1;
         }
     }
     const finalNode = orderedNodes.at(-1);
@@ -237,20 +392,21 @@ function createAssistantTurnNodes(piboSessionId, entries, timing) {
     }
     return orderedNodes;
 }
-function createReasoningNode(piboSessionId, entry, entryIndex, index, thinking) {
+function createReasoningNode(input) {
+    const eventIdentity = input.eventId ? `${input.eventId}:thinking:${input.thinkingIndex}` : undefined;
     return {
-        id: `entry:${entry.id}:thinking:${index}`,
-        entryId: entry.id,
-        piboSessionId,
+        id: eventIdentity ? thinkingNodeId(eventIdentity) : `entry:${input.entry.id}:thinking:${input.contentPartIndex}`,
+        entryId: input.entry.id,
+        piboSessionId: input.piboSessionId,
         type: "model.reasoning",
         title: "Thinking",
         status: "done",
-        startedAt: entry.timestamp,
-        summary: thinking,
-        output: thinking,
+        startedAt: input.entry.timestamp,
+        summary: input.thinking,
+        output: input.thinking,
         source: "transcript",
-        stableKey: `entry:${entry.id}:thinking:${index}`,
-        orderKey: transcriptTraceOrder(entryIndex, index, "model.reasoning"),
+        stableKey: eventIdentity ? `reasoning:${eventIdentity}` : `entry:${input.entry.id}:thinking:${input.contentPartIndex}`,
+        orderKey: transcriptTraceOrder(input.entryIndex, input.contentPartIndex, "model.reasoning"),
         children: [],
     };
 }
@@ -258,7 +414,7 @@ function createToolCallNode(piboSessionId, entry, entryIndex, contentPartIndex,
     const name = typeof part.name === "string" ? part.name : "Tool Call";
     const toolCallId = typeof part.id === "string" ? part.id : undefined;
     return {
-        id: `entry:${entry.id}:tool:${String(part.id)}`,
+        id: toolCallId ? `tool:${toolCallId}` : `entry:${entry.id}:tool:${contentPartIndex}`,
         entryId: entry.id,
         piboSessionId,
         toolCallId,
@@ -293,7 +449,7 @@ function mergePersistedToolResult(toolsByCallId, childNodes, entry, piboSessionI
 function createMissingToolResultNode(piboSessionId, entry, entryIndex, toolCallId) {
     const message = entry.message;
     return {
-        id: `entry:${entry.id}:tool-result:${toolCallId}`,
+        id: `tool:${toolCallId}`,
         entryId: entry.id,
         piboSessionId,
         toolCallId,
@@ -313,10 +469,12 @@ function toolResultOutput(message) {
     return { content: message.content, details: message.details };
 }
 function createAssistantMessageNode(input) {
+    const eventIdentity = input.eventId ? `${input.eventId}:assistant:${input.assistantIndex}` : undefined;
     return {
-        id: input.id,
+        id: eventIdentity ? assistantMessageNodeId(eventIdentity) : `entry:${input.entry.id}:response`,
         entryId: input.entry.id,
         piboSessionId: input.piboSessionId,
+        eventId: input.eventId,
         type: "assistant.message",
         title: "Agent Message",
         status: input.status,
@@ -326,7 +484,7 @@ function createAssistantMessageNode(input) {
         output: input.text,
         error: input.error,
         source: "transcript",
-        stableKey: `entry:${input.entry.id}:response:${input.contentPartIndex}`,
+        stableKey: eventIdentity ? `assistant:${eventIdentity}` : `entry:${input.entry.id}:response:${input.contentPartIndex}`,
         orderKey: transcriptTraceOrder(input.entryIndex, input.contentPartIndex, "assistant.message"),
         children: input.children ?? [],
     };

package/dist/tools/cdp-client.js

@@ -1,5 +1,7 @@
+import { randomUUID } from "node:crypto";
 export const DEFAULT_CDP_URL = "http://127.0.0.1:56663";
 export const DEFAULT_CDP_TIMEOUT_MS = 2_500;
+const CDP_JSON_CHUNK_SIZE = 256 * 1024;
 export class CdpClient {
     webSocketUrl;
     nextId = 0;
@@ -32,10 +34,11 @@ export class CdpClient {
             socket.addEventListener("open", succeed);
             socket.addEventListener("message", (event) => this.handleMessage(String(event.data)));
             socket.addEventListener("error", () => fail(new Error(`CDP WebSocket error connecting to ${this.webSocketUrl}`)));
-            socket.addEventListener("close", () => {
+            socket.addEventListener("close", (event) => {
+                const detail = `code ${event.code}${event.reason ? `: ${event.reason}` : ""}`;
                 for (const [id, pending] of this.pending) {
                     clearTimeout(pending.timer);
-                    pending.reject(new Error("CDP target closed"));
+                    pending.reject(new Error(`CDP target closed during ${pending.method} (${detail})`));
                     this.pending.delete(id);
                 }
             });
@@ -51,11 +54,17 @@ export class CdpClient {
                 this.pending.delete(id);
                 reject(new Error(`Timed out waiting for CDP method ${method}`));
             }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
+            this.pending.set(id, { method, resolve, reject, timer });
         });
         this.socket.send(JSON.stringify(payload));
         return promise;
     }
+    sendDetached(method, params) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+            return;
+        const id = ++this.nextId;
+        this.socket.send(JSON.stringify(params ? { id, method, params } : { id, method }));
+    }
     async evaluate(expression, timeoutMs = 10_000) {
         const response = await this.send("Runtime.evaluate", {
             expression,
@@ -67,6 +76,72 @@ export class CdpClient {
             throw new Error(`Browser evaluation failed: ${JSON.stringify(response.exceptionDetails)}`);
         return response.result?.value;
     }
+    async evaluateJson(expression, timeoutMs = 10_000) {
+        const deadlineMs = Date.now() + timeoutMs;
+        const cleanupReserveMs = Math.min(100, Math.max(1, Math.floor(timeoutMs / 10)));
+        const transferDeadlineMs = deadlineMs - cleanupReserveMs;
+        const storageKey = `__piboCdpJsonResult_${randomUUID()}`;
+        const keyLiteral = JSON.stringify(storageKey);
+        try {
+            const descriptor = await this.evaluate(`(async () => {
+				const deadlineMs = ${deadlineMs};
+				if (Date.now() >= deadlineMs) throw new Error("CDP JSON evaluation exceeded its deadline");
+				const state = { cancelled: false, json: undefined, cleanupTimer: undefined };
+				Object.defineProperty(globalThis, ${keyLiteral}, { value: state, configurable: true });
+				state.cleanupTimer = setTimeout(() => {
+					state.cancelled = true;
+					if (globalThis[${keyLiteral}] === state) delete globalThis[${keyLiteral}];
+				}, Math.max(0, deadlineMs - Date.now()));
+				try {
+					const value = await (${expression});
+					const json = JSON.stringify(value);
+					if (typeof json !== "string") throw new Error("CDP evaluation result is not JSON serializable");
+					if (Date.now() >= deadlineMs || state.cancelled || globalThis[${keyLiteral}] !== state) throw new Error("CDP JSON evaluation exceeded its deadline");
+					state.json = json;
+					return { length: json.length };
+				} catch (error) {
+					state.cancelled = true;
+					clearTimeout(state.cleanupTimer);
+					if (globalThis[${keyLiteral}] === state) delete globalThis[${keyLiteral}];
+					throw error;
+				}
+			})()`, remainingTime(transferDeadlineMs, "evaluating JSON through CDP"));
+            if (!Number.isInteger(descriptor?.length) || descriptor.length < 0)
+                throw new Error("CDP evaluation returned an invalid JSON result length");
+            const chunks = [];
+            for (let offset = 0; offset < descriptor.length; offset += CDP_JSON_CHUNK_SIZE) {
+                const end = Math.min(descriptor.length, offset + CDP_JSON_CHUNK_SIZE);
+                chunks.push(await this.evaluate(`(() => {
+					const state = globalThis[${keyLiteral}];
+					if (!state || typeof state.json !== "string") throw new Error("CDP JSON result storage is unavailable");
+					return state.json.slice(${offset}, ${end});
+				})()`, remainingTime(transferDeadlineMs, "retrieving JSON chunks through CDP")));
+            }
+            return JSON.parse(chunks.join(""));
+        }
+        finally {
+            const cleanupExpression = `(() => {
+				const state = globalThis[${keyLiteral}];
+				if (state && typeof state === "object") {
+					state.cancelled = true;
+					clearTimeout(state.cleanupTimer);
+				}
+				return delete globalThis[${keyLiteral}];
+			})()`;
+            const cleanupTimeoutMs = remainingTimeOrZero(deadlineMs);
+            if (cleanupTimeoutMs > 0) {
+                await this.evaluate(cleanupExpression, cleanupTimeoutMs).catch(() => undefined);
+            }
+            else {
+                this.sendDetached("Runtime.evaluate", {
+                    expression: cleanupExpression,
+                    awaitPromise: true,
+                    returnByValue: true,
+                    userGesture: true,
+                });
+            }
+        }
+    }
     close() {
         try {
             this.socket?.close();
@@ -187,3 +262,12 @@ function optionalStringValue(value) {
     const text = stringValue(value);
     return text || undefined;
 }
+function remainingTime(deadlineMs, operation) {
+    const remainingMs = remainingTimeOrZero(deadlineMs);
+    if (remainingMs <= 0)
+        throw new Error(`Timed out ${operation}`);
+    return remainingMs;
+}
+function remainingTimeOrZero(deadlineMs) {
+    return Math.max(0, Math.floor(deadlineMs - Date.now()));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.11.4",
+  "version": "1.12.1",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"