@pasko70/pibo 1.9.9 → 1.9.11

package/dist/debug/web-streaming-browser-scripts.js

@@ -0,0 +1,242 @@
+import { browserStreamingBenchmarkLibrary } from "./web-streaming-browser-library.js";
+export function streamingBenchmarkEventSourceProbeScript() {
+    return String.raw `
+(() => {
+  if (window.__piboStreamingBenchmarkEventSourceProbeInstalled || typeof window.EventSource !== 'function') return;
+  const OriginalEventSource = window.EventSource;
+  const probe = {
+    createdAt: new Date().toISOString(),
+    openCount: 0,
+    errorCount: 0,
+    closeCount: 0,
+    forcedCloseCount: 0,
+    textDropRequested: false,
+    textDropDurationMs: undefined,
+    textDropUntil: 0,
+    textDropCount: 0,
+    textDropTextEventCount: 0,
+    events: [],
+    connections: [],
+  };
+  Object.defineProperty(probe, '_instances', { value: [], enumerable: false, configurable: false });
+  function at() { return typeof performance === 'undefined' ? Date.now() : performance.now(); }
+  function isChatEventsUrl(url) { return String(url || '').includes('/api/chat/events'); }
+  function pushConnection(kind, info, extra) {
+    probe.connections.push({ t: at(), kind, url: info.url, ...(extra || {}) });
+    if (probe.connections.length > 200) probe.connections.splice(0, probe.connections.length - 200);
+  }
+  function WrappedEventSource(url, init) {
+    const events = new OriginalEventSource(url, init);
+    const info = { url: String(url), createdAt: at(), closed: false, forcedClosing: false };
+    probe._instances.push({ events, info });
+    events.addEventListener('open', () => {
+      probe.openCount += 1;
+      pushConnection('open', info, { readyState: events.readyState });
+    });
+    events.addEventListener('error', () => {
+      probe.errorCount += 1;
+      pushConnection('error', info, { readyState: events.readyState });
+    });
+    events.addEventListener('pibo', (message) => {
+      let payload;
+      try { payload = JSON.parse(message.data); } catch {}
+      const type = payload && typeof payload.type === 'string' ? payload.type : undefined;
+      const record = {
+        t: at(),
+        url: info.url,
+        lastEventId: message.lastEventId || '',
+        type: typeof type === 'string' ? type : undefined,
+        liveReplayId: payload && typeof payload.liveReplayId === 'number' && Number.isFinite(payload.liveReplayId) ? payload.liveReplayId : undefined,
+        liveReplayReplayed: payload && payload.liveReplay && typeof payload.liveReplay.replayed === 'number' && Number.isFinite(payload.liveReplay.replayed) ? payload.liveReplay.replayed : undefined,
+        liveReplayMissed: Boolean(payload && payload.liveReplay && payload.liveReplay.missed === true),
+        liveReplayEvictedBefore: payload && payload.liveReplay && typeof payload.liveReplay.evictedBefore === 'number' && Number.isFinite(payload.liveReplay.evictedBefore) ? payload.liveReplay.evictedBefore : undefined,
+        liveReplayRequestedAfter: payload && payload.liveReplay && typeof payload.liveReplay.requestedAfter === 'number' && Number.isFinite(payload.liveReplay.requestedAfter) ? payload.liveReplay.requestedAfter : undefined,
+        liveReplayNewestAvailable: payload && payload.liveReplay && typeof payload.liveReplay.newestAvailable === 'number' && Number.isFinite(payload.liveReplay.newestAvailable) ? payload.liveReplay.newestAvailable : undefined,
+      };
+      probe.events.push(record);
+      if (probe.events.length > 1000) probe.events.splice(0, probe.events.length - 1000);
+    });
+    const originalClose = events.close.bind(events);
+    events.close = () => {
+      if (!info.closed) {
+        info.closed = true;
+        probe.closeCount += 1;
+        pushConnection('close', info, { forced: Boolean(info.forcedClosing), readyState: events.readyState });
+      }
+      return originalClose();
+    };
+    return events;
+  }
+  WrappedEventSource.prototype = OriginalEventSource.prototype;
+  Object.setPrototypeOf(WrappedEventSource, OriginalEventSource);
+  window.EventSource = WrappedEventSource;
+  window.__piboStreamingBenchmarkMarkTextDropRequested = (durationMs) => {
+    const duration = Math.max(0, Number(durationMs || 0));
+    probe.textDropRequested = true;
+    probe.textDropDurationMs = duration;
+    probe.textDropUntil = at() + duration;
+    probe.textDropCount = 0;
+    probe.textDropTextEventCount = 0;
+    return { durationMs: duration };
+  };
+  window.__piboStreamingBenchmarkForceReconnect = () => {
+    let closed = 0;
+    for (const entry of probe._instances) {
+      if (!entry || !entry.events || !isChatEventsUrl(entry.info && entry.info.url)) continue;
+      if (entry.events.readyState === 2) continue;
+      entry.info.forcedClosing = true;
+      probe.forcedCloseCount += 1;
+      entry.events.close();
+      closed += 1;
+    }
+    window.dispatchEvent(new Event('online'));
+    window.dispatchEvent(new Event('focus'));
+    return closed;
+  };
+  window.__piboStreamingBenchmarkEventSourceProbe = probe;
+  window.__piboStreamingBenchmarkEventSourceProbeInstalled = true;
+})();
+`;
+}
+export function streamingBenchmarkFixtureHtml(fixtureProfile, fixtureMix) {
+    return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Streaming Benchmark Fixture</title>
+<style>body{font-family:system-ui,sans-serif;margin:24px;line-height:1.4} [data-pibo-component]{white-space:pre-wrap}</style>
+</head>
+<body data-pibo-debug="chat-app">
+<h1>Streaming Benchmark Fixture</h1>
+<div data-pibo-component="MarkdownRendererHost" data-pibo-markdown-kind="assistant-message">hello</div>
+<script>
+(() => {
+  function nowIso() { return new Date().toISOString(); }
+  const target = document.querySelector('[data-pibo-component="MarkdownRendererHost"]');
+  const textDeltas = [' a', ' b', ' c', ' d', ' e', ' f', ' g', ' h', ' i', ' j', ' k', ' l'];
+  const markdownDeltas = [' **a**', ' **b**', ' **c**', ' **d**', ' **e**', ' **f**', ' **g**', ' **h**', ' **i**', ' **j**', ' **k**', ' **l**'];
+  const gfmMarkdownDeltas = [' ~~a~~', ' ~~b~~', ' ~~c~~', ' ~~d~~', ' ~~e~~', ' ~~f~~', ' ~~g~~', ' ~~h~~', ' ~~i~~', ' ~~j~~', ' ~~k~~', ' ~~l~~'];
+  const gfmTaskMarkdownDeltas = ['- [ ] [_**a**_](https://e.co/a)', ' [_**b**_](https://e.co/b)', ' [_**c**_](https://e.co/c)', ' [_**d**_](https://e.co/d)', ' [_**e**_](https://e.co/e)', ' [_**f**_](https://e.co/f)', ' [_**g**_](https://e.co/g)', ' [_**h**_](https://e.co/h)', ' [_**i**_](https://e.co/i)', ' [_**j**_](https://e.co/j)', ' [_**k**_](https://e.co/k)', ' [_**l**_](https://e.co/l)'];
+  const gfmFullMarkdownDeltas = ['- [ ] [_~~a~~_](https://e.co/a)', ' [_~~b~~_](https://e.co/b)', ' [_~~c~~_](https://e.co/c)', ' [_~~d~~_](https://e.co/d)', ' [_~~e~~_](https://e.co/e)', ' [_~~f~~_](https://e.co/f)', ' [_~~g~~_](https://e.co/g)', ' [_~~h~~_](https://e.co/h)', ' [_~~i~~_](https://e.co/i)', ' [_~~j~~_](https://e.co/j)', ' [_~~k~~_](https://e.co/k)', ' [_~~l~~_](https://e.co/l)'];
+  const cadenceMs = 100;
+  const profile = ${JSON.stringify(fixtureProfile)};
+  const mix = ${JSON.stringify(fixtureMix)};
+  const deltas = mix === 'markdown' ? markdownDeltas : (mix === 'gfm-markdown' ? gfmMarkdownDeltas : (mix === 'gfm-task-markdown' ? gfmTaskMarkdownDeltas : (mix === 'gfm-full-markdown' ? gfmFullMarkdownDeltas : textDeltas)));
+  const reasoningDeltas = mix === 'reasoning-text' ? [' think', ' plan', ' check', ' answer'] : [];
+  const scheduleMs = buildSchedule(deltas.length, cadenceMs, profile);
+  const reasoningScheduleMs = reasoningDeltas.map((_, index) => Math.max(10, Math.round((index + 1) * cadenceMs / 2)));
+  let timers = [];
+  function buildSchedule(count, cadence, timingProfile) {
+    const delays = [];
+    let elapsed = 0;
+    for (let index = 0; index < count; index += 1) {
+      let gap = cadence;
+      if (timingProfile === 'jitter') {
+        const jitter = [-30, 50, -20, 30, -40, 60, -10, 40, -50, 70, -20, 30][index % 12];
+        gap = Math.max(10, cadence + jitter);
+      } else if (timingProfile === 'burst') {
+        gap = index > 0 && index % 3 !== 0 ? Math.max(10, Math.round(cadence / 5)) : Math.max(cadence, Math.round(cadence * 2.5));
+      } else if (timingProfile === 'batch') {
+        gap = index % 4 === 0 ? Math.max(cadence, Math.round(cadence * 3)) : 0;
+      }
+      elapsed += gap;
+      delays.push(elapsed);
+    }
+    return delays;
+  }
+  function snapshot() {
+    const now = nowIso();
+    return {
+      startedAt: now,
+      updatedAt: now,
+      eventCount: 0,
+      textDeltaCount: 0,
+      textDeltaBytes: 0,
+      reasoningDeltaCount: 0,
+      reasoningDeltaBytes: 0,
+      enqueueCount: 0,
+      flushCount: 0,
+      flushedEventCount: 0,
+      overlayUpdateCount: 0,
+      overlayEventCount: 0,
+      traceRefreshStartedCount: 0,
+      traceRefreshCompletedCount: 0,
+      traceRefreshFailedCount: 0,
+      traceBaseUpdateCount: 0,
+      traceBaseOutputLength: 0,
+      currentOutputLength: target.textContent.length,
+      lastDurableCursor: undefined,
+      lastTransientLiveId: 'live:-1',
+    };
+  }
+  window.__piboStreamingDebugReset = () => {
+    for (const timer of timers) clearTimeout(timer);
+    timers = [];
+    target.textContent = 'hello';
+    window.__piboStreamingDebug = snapshot();
+    return window.__piboStreamingDebug;
+  };
+  window.__piboStreamingFixtureConfig = { deltaCount: deltas.length, reasoningDeltaCount: reasoningDeltas.length, cadenceMs, profile, mix, scheduleMs, reasoningScheduleMs, textBytes: deltas.join('').length, reasoningBytes: reasoningDeltas.join('').length };
+  window.__piboStreamingFixtureStart = () => {
+    window.__piboStreamingDebugReset();
+    reasoningDeltas.forEach((delta, index) => {
+      timers.push(setTimeout(() => {
+        const debug = window.__piboStreamingDebug;
+        const at = nowIso();
+        debug.eventCount += 1;
+        debug.firstEventAt ??= at;
+        debug.firstReasoningDeltaAt ??= at;
+        debug.reasoningDeltaCount += 1;
+        debug.reasoningDeltaBytes += delta.length;
+        debug.firstEnqueueAt ??= at;
+        debug.enqueueCount += 1;
+        debug.firstFlushAt ??= at;
+        debug.flushCount += 1;
+        debug.flushedEventCount += 1;
+        debug.firstOverlayUpdateAt ??= at;
+        debug.overlayUpdateCount += 1;
+        debug.overlayEventCount += 1;
+        debug.lastEventAt = at;
+        debug.updatedAt = at;
+        debug.lastTransientLiveId = 'live:reasoning-' + index;
+      }, reasoningScheduleMs[index]));
+    });
+    deltas.forEach((delta, index) => {
+      timers.push(setTimeout(() => {
+        target.textContent += delta;
+        const debug = window.__piboStreamingDebug;
+        const at = nowIso();
+        debug.eventCount += 1;
+        debug.firstEventAt ??= at;
+        debug.firstTextDeltaAt ??= at;
+        debug.textDeltaCount += 1;
+        debug.textDeltaBytes += delta.length;
+        debug.firstEnqueueAt ??= at;
+        debug.enqueueCount += 1;
+        debug.firstFlushAt ??= at;
+        debug.flushCount += 1;
+        debug.flushedEventCount += 1;
+        debug.firstOverlayUpdateAt ??= at;
+        debug.overlayUpdateCount += 1;
+        debug.overlayEventCount += 1;
+        debug.currentOutputLength = target.textContent.length;
+        debug.lastEventAt = at;
+        debug.updatedAt = at;
+        debug.lastTransientLiveId = 'live:' + index;
+      }, scheduleMs[index]));
+    });
+    return window.__piboStreamingFixtureConfig;
+  };
+  window.__piboStreamingDebugReset();
+})();
+</script>
+</body>
+</html>`;
+}
+export function buildStreamingBenchmarkExpression(durationMs, input = {}) {
+    return `(async () => {
+  const options = ${JSON.stringify({ durationMs, startFixture: Boolean(input.startFixture), startBackendFixture: Boolean(input.startBackendFixture), fixtureProfile: input.fixtureProfile ?? "steady", fixtureMix: input.fixtureMix ?? "text", fixturePreludeMessages: input.fixturePreludeMessages ?? 0, simulateReconnect: Boolean(input.simulateReconnect), simulateTraceCatchup: Boolean(input.simulateTraceCatchup), simulateOverlayDrop: Boolean(input.simulateOverlayDrop), reconnectAtMs: input.simulateReconnect ? 325 : undefined, traceCatchupDropMs: input.simulateTraceCatchup ? 1300 : undefined })};
+  ${browserStreamingBenchmarkLibrary()}
+  return await runStreamingBenchmark(options);
+})()`;
+}

package/dist/debug/web-streaming-provider-telemetry.js

@@ -0,0 +1,194 @@
+import { resolveDebugStore } from "./stores.js";
+import { inspectTelemetryProvider, inspectTelemetryProviderEvents, inspectTelemetrySession, inspectTelemetryTurn } from "./telemetry.js";
+export function summarizeStreamingProviderTelemetry(input) {
+    const request = input.request;
+    const startedAt = stringField(request, "startedAt");
+    const textEvents = input.events.filter(isProviderTextDeltaEvent);
+    const reasoningEvents = input.events.filter(isProviderReasoningDeltaEvent);
+    const textReceivedAt = textEvents.map((event) => stringField(event, "receivedAt")).filter((value) => Boolean(value));
+    const reasoningReceivedAt = reasoningEvents.map((event) => stringField(event, "receivedAt")).filter((value) => Boolean(value));
+    return {
+        requested: true,
+        available: true,
+        providerRequestId: input.providerRequestId ?? stringField(request, "providerRequestId") ?? "unknown",
+        piboSessionId: stringField(request, "piboSessionId"),
+        turnId: stringField(request, "turnId"),
+        provider: stringField(request, "provider"),
+        api: stringField(request, "api"),
+        model: stringField(request, "model"),
+        transport: stringField(request, "transport"),
+        status: stringField(request, "status"),
+        startedAt,
+        completedAt: stringField(request, "completedAt"),
+        httpStatus: optionalNumberField(request, "httpStatus"),
+        upstreamResponseId: stringField(request, "upstreamResponseId"),
+        rawEventCount: optionalNumberField(request, "rawEventCount"),
+        normalizedEventCount: optionalNumberField(request, "normalizedEventCount"),
+        parseErrorCount: optionalNumberField(request, "parseErrorCount"),
+        unknownEventCount: optionalNumberField(request, "unknownEventCount"),
+        firstByteLatencyMs: durationBetweenMs(startedAt, stringField(request, "firstByteAt")),
+        firstTextLatencyMs: durationBetweenMs(startedAt, textReceivedAt[0]),
+        firstReasoningLatencyMs: durationBetweenMs(startedAt, reasoningReceivedAt[0]),
+        eventTypeCounts: recordField(request, "eventTypeCounts"),
+        textDeltaCount: textEvents.length,
+        reasoningDeltaCount: reasoningEvents.length,
+        textDeltaBytes: numericStats(textEvents.map(providerDeltaBytes)),
+        reasoningDeltaBytes: numericStats(reasoningEvents.map(providerDeltaBytes)),
+        textDeltaGapsMs: numericStats(gapsBetweenIso(textReceivedAt)),
+        reasoningDeltaGapsMs: numericStats(gapsBetweenIso(reasoningReceivedAt)),
+        eventPageCount: input.eventPageCount ?? 1,
+        truncated: input.truncated === true,
+    };
+}
+export async function collectStreamingProviderTelemetryFromSelectedBrowserSession(client) {
+    const selected = await client.evaluate(`(() => ({
+  piboSessionId: document.querySelector('[data-pibo-debug="chat-shell"]')?.getAttribute('data-pibo-session-id')
+    || document.querySelector('[data-pibo-selected-session-id]')?.getAttribute('data-pibo-selected-session-id')
+    || undefined,
+}))()`, 5_000).catch(() => ({}));
+    const piboSessionId = isRecord(selected) && typeof selected.piboSessionId === "string" ? selected.piboSessionId : undefined;
+    if (!piboSessionId)
+        return unavailableStreamingProviderTelemetry("selected-session", "No selected Chat session was found in the current browser target.");
+    return collectStreamingProviderTelemetryFromSession(piboSessionId);
+}
+export function collectStreamingProviderTelemetry(providerRequestId, store = resolveDebugStore("pibo-data")) {
+    const provider = inspectTelemetryProvider(store, providerRequestId);
+    if (!provider.available)
+        return unavailableStreamingProviderTelemetry(providerRequestId, provider.message);
+    const events = [];
+    let after;
+    let pageCount = 0;
+    let truncated = false;
+    for (;;) {
+        const page = inspectTelemetryProviderEvents(store, providerRequestId, { limit: "200", after });
+        if (!page.available)
+            return unavailableStreamingProviderTelemetry(providerRequestId, page.message);
+        pageCount += 1;
+        events.push(...page.rows);
+        if (!page.page.hasMore || page.page.nextAfterSequence === undefined)
+            break;
+        if (pageCount >= 50) {
+            truncated = true;
+            break;
+        }
+        after = String(page.page.nextAfterSequence);
+    }
+    return summarizeStreamingProviderTelemetry({ request: provider.request, events, providerRequestId, truncated, eventPageCount: pageCount });
+}
+export function collectStreamingProviderTelemetryFromSession(piboSessionId) {
+    const store = resolveDebugStore("pibo-data");
+    const session = inspectTelemetrySession(store, piboSessionId, { limit: "20" });
+    if (!session.available)
+        return unavailableStreamingProviderTelemetry(`session:${piboSessionId}`, session.message);
+    const directProviderRequestId = latestProviderRequestId(session.detail.providerRequests);
+    if (directProviderRequestId)
+        return collectStreamingProviderTelemetry(directProviderRequestId, store);
+    for (const turn of session.detail.recentTurns) {
+        const timeline = inspectTelemetryTurn(store, turn.turnId, { limit: "20" });
+        if (!timeline.available)
+            continue;
+        const providerRequestId = latestProviderRequestId(timeline.timeline.providerRequests);
+        if (providerRequestId)
+            return collectStreamingProviderTelemetry(providerRequestId, store);
+    }
+    return unavailableStreamingProviderTelemetry(`session:${piboSessionId}`, `No provider request found for Pibo Session ${piboSessionId}.`);
+}
+export function collectStreamingProviderTelemetryFromTurn(turnIdOrEventId) {
+    const store = resolveDebugStore("pibo-data");
+    const timeline = inspectTelemetryTurn(store, turnIdOrEventId, { limit: "20" });
+    if (!timeline.available)
+        return unavailableStreamingProviderTelemetry(`turn:${turnIdOrEventId}`, timeline.message);
+    const providerRequestId = latestProviderRequestId(timeline.timeline.providerRequests);
+    if (providerRequestId)
+        return collectStreamingProviderTelemetry(providerRequestId, store);
+    return unavailableStreamingProviderTelemetry(`turn:${turnIdOrEventId}`, `No provider request found for turn or event ${turnIdOrEventId}.`);
+}
+function latestProviderRequestId(providerRequests) {
+    for (let index = providerRequests.length - 1; index >= 0; index--) {
+        const providerRequestId = providerRequests[index]?.providerRequestId;
+        if (providerRequestId)
+            return providerRequestId;
+    }
+    return undefined;
+}
+function unavailableStreamingProviderTelemetry(providerRequestId, message) {
+    return {
+        requested: true,
+        available: false,
+        providerRequestId,
+        textDeltaCount: 0,
+        reasoningDeltaCount: 0,
+        textDeltaBytes: numericStats([]),
+        reasoningDeltaBytes: numericStats([]),
+        textDeltaGapsMs: numericStats([]),
+        reasoningDeltaGapsMs: numericStats([]),
+        eventPageCount: 0,
+        truncated: false,
+        error: message,
+    };
+}
+function isProviderTextDeltaEvent(event) {
+    return stringField(event, "normalizedType") === "assistant_delta" || stringField(event, "eventType") === "pi.text_delta";
+}
+function isProviderReasoningDeltaEvent(event) {
+    const normalizedType = stringField(event, "normalizedType");
+    const eventType = stringField(event, "eventType") ?? "";
+    return normalizedType === "thinking_delta" || eventType === "pi.thinking_delta" || (eventType.includes("reasoning") && eventType.includes("delta"));
+}
+function providerDeltaBytes(event) {
+    const safeFields = recordField(event, "safeFields");
+    return optionalNumberField(safeFields, "deltaBytes") ?? optionalNumberField(safeFields, "contentBytes") ?? optionalNumberField(event, "byteSize");
+}
+function gapsBetweenIso(values) {
+    const gaps = [];
+    let previous;
+    for (const value of values) {
+        const current = Date.parse(value);
+        if (!Number.isFinite(current))
+            continue;
+        if (previous !== undefined)
+            gaps.push(round3(current - previous));
+        previous = current;
+    }
+    return gaps;
+}
+function durationBetweenMs(start, end) {
+    if (!start || !end)
+        return undefined;
+    const startMs = Date.parse(start);
+    const endMs = Date.parse(end);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs))
+        return undefined;
+    return round3(endMs - startMs);
+}
+function stringField(value, key) {
+    return isRecord(value) && typeof value[key] === "string" ? value[key] : undefined;
+}
+function recordField(value, key) {
+    return isRecord(value) && isRecord(value[key]) ? value[key] : undefined;
+}
+function optionalNumberField(value, key) {
+    return isRecord(value) && typeof value[key] === "number" && Number.isFinite(value[key]) ? value[key] : undefined;
+}
+function numericStats(values) {
+    const nums = values.filter((value) => typeof value === "number" && Number.isFinite(value)).sort((left, right) => left - right);
+    if (!nums.length)
+        return { count: 0 };
+    const pick = (quantile) => nums[Math.min(nums.length - 1, Math.floor((nums.length - 1) * quantile))] ?? nums[nums.length - 1] ?? 0;
+    const avg = nums.reduce((total, value) => total + value, 0) / nums.length;
+    return {
+        count: nums.length,
+        min: round3(nums[0]),
+        p50: round3(pick(0.50)),
+        p90: round3(pick(0.90)),
+        p99: round3(pick(0.99)),
+        max: round3(nums[nums.length - 1]),
+        avg: round3(avg),
+    };
+}
+function round3(value) {
+    return Math.round(value * 1000) / 1000;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}