oc-metricboard 0.1.13 → 0.1.15

package/dist/assistant-progress.js

@@ -0,0 +1,66 @@
+import { estimateTokens } from "./metrics";
+import { parseAssistantTextDelta } from "./event-shapes";
+import { currentRequest } from "./request-state";
+import { eventAggregateID, eventID, eventProperties, stringEventProperty } from "./event-bus";
+import { recordLiveTokens } from "./live-speed";
+import { ensureTurn, recordTurnFirstToken } from "./turn-state";
+function partEstimateKey(sessionID, messageID, partID) {
+    return `${sessionID}:${messageID}:${partID}`;
+}
+function applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now) {
+    const { actions, state } = ctx;
+    if (state.turns.get(sessionID)?.finalizedSteps.has(messageID))
+        return;
+    const current = currentRequest({ state, actions, sessionID, messageID, now });
+    if (current.firstTokenTime === null)
+        current.firstTokenTime = now;
+    recordTurnFirstToken(ensureTurn(state.turns, sessionID, now), now);
+    if (deltaTokens > 0) {
+        current.estimatedOutputTokens += deltaTokens;
+        current.lastDeltaTime = now;
+        recordLiveTokens(state.liveSpeeds, sessionID, messageID, deltaTokens, now);
+    }
+    current.isStreaming = true;
+    actions.notify();
+}
+function applyAssistantText(ctx, sessionID, messageID, partID, text, now) {
+    const { actions, config, state } = ctx;
+    const key = partEstimateKey(sessionID, messageID, partID);
+    const nextTokens = estimateTokens(text, config.estimationRatio);
+    const previousTokens = state.partTokenEstimates.get(key) ?? 0;
+    const deltaTokens = Math.max(0, nextTokens - previousTokens);
+    state.partTokenEstimates.set(key, Math.max(previousTokens, nextTokens));
+    applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now);
+}
+export function applyAssistantProgress(ctx, sessionID, part, now) {
+    applyAssistantText(ctx, sessionID, part.messageID, part.partID, part.text, now);
+}
+export function applyAssistantDelta(ctx, event) {
+    const { actions, state } = ctx;
+    const sessionID = stringEventProperty(event, "sessionID");
+    const fallbackMessageID = sessionID.length > 0 ? state.assistantMessageIds.get(sessionID) ?? eventID(event) : eventID(event);
+    const text = parseAssistantTextDelta(eventProperties(event), fallbackMessageID);
+    if (!text)
+        return;
+    const aggregateID = eventAggregateID(event);
+    if (aggregateID.length > 0 && aggregateID !== text.sessionID) {
+        const aggregateAliases = state.sessionAliases.get(aggregateID) ?? new Set();
+        aggregateAliases.add(text.sessionID);
+        state.sessionAliases.set(aggregateID, aggregateAliases);
+        const sessionAliases = state.sessionAliases.get(text.sessionID) ?? new Set();
+        sessionAliases.add(aggregateID);
+        state.sessionAliases.set(text.sessionID, sessionAliases);
+    }
+    const now = performance.now();
+    actions.startSessionTiming(text.sessionID, now);
+    const key = partEstimateKey(text.sessionID, text.messageID, text.partID);
+    const deltaTokens = estimateTokens(text.delta, ctx.config.estimationRatio);
+    state.partTokenEstimates.set(key, (state.partTokenEstimates.get(key) ?? 0) + deltaTokens);
+    applyTokenDelta(ctx, text.sessionID, text.messageID, deltaTokens, now);
+}
+export function applyAssistantPartDelta(ctx, sessionID, messageID, partID, delta, now) {
+    const key = partEstimateKey(sessionID, messageID, partID);
+    const deltaTokens = estimateTokens(delta, ctx.config.estimationRatio);
+    ctx.state.partTokenEstimates.set(key, (ctx.state.partTokenEstimates.get(key) ?? 0) + deltaTokens);
+    applyTokenDelta(ctx, sessionID, messageID, deltaTokens, now);
+}

package/dist/badge-contrast.js

@@ -0,0 +1,50 @@
+/**
+ * Pick the text color for the sidebar header badge (a bold label drawn on a
+ * `theme.accent` background).
+ *
+ * Primary rule: paint the theme's own `background` color as the label, giving
+ * the inverse-of-panel look consistent with other sidebar plugins.
+ *
+ * Fallback rule: `theme.background` can be unusable as a label color when:
+ *   1. Transparent background (alpha < 0.5). Drawing transparent text on the
+ *      accent renders the label invisible.
+ *   2. Background ~= accent (per-channel distance < 0.06). No contrast.
+ * In either case we fall back to a black/white pick by accent luminance.
+ *
+ * Accepts the minimal `{ r, g, b, a? }` shape so this stays a pure, trivially
+ * testable function independent of the native color class.
+ */
+const MIN_OPAQUE_ALPHA = 0.5;
+const MIN_CHANNEL_DISTANCE = 0.06;
+const LIGHT_ACCENT_LUMINANCE = 0.5;
+function srgbChannelToLinear(c) {
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function relativeLuminance(bg) {
+    return (0.2126 * srgbChannelToLinear(bg.r) +
+        0.7152 * srgbChannelToLinear(bg.g) +
+        0.0722 * srgbChannelToLinear(bg.b));
+}
+function nearlyEqual(a, b) {
+    return (Math.abs(a.r - b.r) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.g - b.g) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.b - b.b) < MIN_CHANNEL_DISTANCE);
+}
+/**
+ * Pure black/white pick by accent luminance. Used as the badge fallback.
+ */
+export function readableTextColorOn(bg) {
+    return relativeLuminance(bg) < LIGHT_ACCENT_LUMINANCE ? "#ffffff" : "#000000";
+}
+/**
+ * Badge label color on the accent: the theme background when it is usable,
+ * else a guaranteed-visible black/white fallback. Returns the passed-in
+ * `background` reference unchanged on the primary path.
+ */
+export function badgeTextColor(accent, background) {
+    const alpha = background.a ?? 1;
+    if (alpha >= MIN_OPAQUE_ALPHA && !nearlyEqual(accent, background)) {
+        return background;
+    }
+    return readableTextColorOn(accent);
+}

package/dist/collector-state.js

@@ -0,0 +1 @@
+export {};