@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/web-ui/app/lib/context-compaction-state.js

@@ -0,0 +1,172 @@
+import {
+  compareContextEvidence,
+  canReplaceContextWindowEvidence,
+} from "./context-window-snapshot-order.js";
+import { selectCompactionPercentages } from "./context-window-measurement.js";
+
+function terminalFingerprint(event) {
+  const fields = [
+    "name",
+    "modelStep",
+    "profileId",
+    "provider",
+    "model",
+    "activationId",
+    "modelInvocationScope",
+    "compactionScope",
+    "scopeId",
+    "sourceRevision",
+    "coveredSourceCount",
+    "beforeInputTokens",
+    "afterInputTokens",
+    "contextWindowTokens",
+    "beforeUsedContextPercent",
+    "afterUsedContextPercent",
+    "issueCode",
+    "reason",
+  ];
+  return JSON.stringify(
+    fields.map((key) => [key, typeof event[key], String(event[key])]),
+  );
+}
+
+function hasConflictingCycleBinding(cycle, event) {
+  for (const key of [
+    "modelStep",
+    "profileId",
+    "provider",
+    "model",
+    "activationId",
+    "modelInvocationScope",
+  ]) {
+    if (cycle[key] && event[key] && cycle[key] !== event[key]) return true;
+  }
+  return false;
+}
+
+function cycleIdentity(event) {
+  const identity = {};
+  for (const key of [
+    "requestId",
+    "generation",
+    "invocationId",
+    "modelStep",
+    "profileId",
+    "provider",
+    "model",
+    "activationId",
+    "modelInvocationScope",
+  ]) {
+    identity[key] = event[key] || "";
+  }
+  return identity;
+}
+
+function canConfirmCompactionTerminal(event, requestTerminal) {
+  if (!requestTerminal) return true;
+  const difference = compareContextEvidence(event, requestTerminal);
+  return difference === null || difference > 0;
+}
+
+export function reduceContextCompaction(cycles, event, requestTerminal = null) {
+  const phase = event.name?.replace("context.compaction.", "");
+  if (!["started", "completed", "failed"].includes(phase)) return cycles;
+  if (typeof event.invocationId !== "string" || !event.invocationId.trim())
+    return cycles;
+  const previous = cycles.get(event.invocationId);
+  if (previous && hasConflictingCycleBinding(previous, event)) {
+    return new Map(cycles).set(event.invocationId, {
+      ...previous,
+      status: "conflicted",
+    });
+  }
+  const cycle = previous || {
+    ...cycleIdentity(event),
+    status: "pending",
+    started: null,
+    terminals: [],
+    interruptedAt: requestTerminal,
+  };
+  if (phase === "started") {
+    if (cycle.started || cycle.terminals.length) return cycles;
+    const next = {
+      ...cycle,
+      started: event,
+      status: cycle.interruptedAt ? "interrupted" : "pending",
+    };
+    return new Map(cycles).set(event.invocationId, next);
+  }
+  const fingerprint = terminalFingerprint(event);
+  if (cycle.terminals.some((receipt) => receipt.fingerprint === fingerprint))
+    return cycles;
+  const terminals = [...cycle.terminals, { event, fingerprint }];
+  let status = phase;
+  if (!canConfirmCompactionTerminal(event, cycle.interruptedAt))
+    status = "interrupted";
+  if (terminals.length > 1 || cycle.status === "conflicted")
+    status = "conflicted";
+  return new Map(cycles).set(event.invocationId, {
+    ...cycle,
+    status,
+    terminals,
+  });
+}
+
+export function interruptContextCompactions(cycles, terminal) {
+  const next = new Map(cycles);
+  for (const [id, cycle] of cycles) {
+    if (cycle.status === "conflicted") continue;
+    const receipt = cycle.terminals[0];
+    const hasConfirmedTerminal =
+      receipt && canConfirmCompactionTerminal(receipt.event, terminal);
+    const status = hasConfirmedTerminal
+      ? receipt.event.name.replace("context.compaction.", "")
+      : "interrupted";
+    next.set(id, { ...cycle, status, interruptedAt: terminal });
+  }
+  return next;
+}
+
+function preferLaterCycle(previous, incoming, eventOf) {
+  if (!previous) return incoming;
+  if (canReplaceContextWindowEvidence(eventOf(previous), eventOf(incoming)))
+    return incoming;
+  return previous;
+}
+
+export function projectContextCompactions(cycles) {
+  let pendingCompaction = null;
+  let lastCompaction = null;
+  let lastCompactionEvent = null;
+  let openCompactionCount = 0;
+  for (const cycle of cycles.values()) {
+    if (cycle.status === "pending") {
+      openCompactionCount += 1;
+      pendingCompaction = preferLaterCycle(
+        pendingCompaction,
+        cycle,
+        (value) => value.started,
+      );
+    }
+    for (const receipt of cycle.terminals) {
+      if (canReplaceContextWindowEvidence(lastCompactionEvent, receipt.event))
+        lastCompactionEvent = receipt.event;
+    }
+    if (cycle.status !== "completed") continue;
+    const event = cycle.terminals[0].event;
+    const percentages = selectCompactionPercentages(event);
+    if (!percentages) continue;
+    const candidate = { ...cycleIdentity(event), ...percentages, event };
+    lastCompaction = preferLaterCycle(
+      lastCompaction,
+      candidate,
+      (value) => value.event,
+    );
+  }
+  return {
+    pendingCompaction,
+    lastCompaction,
+    lastCompactionEvent,
+    openCompactionCount,
+  };
+}

package/dist/src/web-ui/app/lib/context-window-measurement.d.ts

@@ -0,0 +1,33 @@
+export type ContextInputMeasurement = Readonly<{
+  inputTokens: number;
+  measurementKind: "actual" | "estimated";
+  measurement: "actual" | "estimated";
+  source: string;
+  contextWindowTokens: number;
+  usedContextPercent: number;
+  remainingContextTokens: number;
+  remainingContextPercent: number;
+  estimatedInputTokens?: number;
+  measuredInputTokens?: number;
+  metadataMismatch: boolean;
+}>;
+export type ContextProviderCounts = Readonly<{
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}>;
+export declare function isContextTokenCount(value: unknown): value is number;
+export declare function isContextCapacity(value: unknown): value is number;
+export declare function contextUsedPercent(
+  inputTokens: number,
+  capacity: number,
+): number;
+export declare function selectContextInputMeasurement(
+  message: Record<string, unknown>,
+): ContextInputMeasurement | null;
+export declare function normalizeContextProviderCounts(
+  message: Record<string, unknown>,
+): ContextProviderCounts | null;
+export declare function selectCompactionPercentages(
+  message: Record<string, unknown>,
+): { beforePercent: number; afterPercent: number } | null;

package/dist/src/web-ui/app/lib/context-window-measurement.js

@@ -0,0 +1,99 @@
+/** Numeric evidence is never coerced: null and missing counts are unknown. */
+export function isContextTokenCount(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+export function isContextCapacity(value) {
+  return isContextTokenCount(value) && value > 0;
+}
+
+export function contextUsedPercent(inputTokens, capacity) {
+  return Math.round((inputTokens / capacity) * 1000) / 10;
+}
+
+export function selectContextInputMeasurement(message) {
+  if (!isContextCapacity(message.contextWindowTokens)) return null;
+  const actual = isContextTokenCount(message.measuredInputTokens);
+  if (!actual && !isContextTokenCount(message.estimatedInputTokens))
+    return null;
+  const inputTokens = actual
+    ? message.measuredInputTokens
+    : message.estimatedInputTokens;
+  const measurementKind = actual ? "actual" : "estimated";
+  const source = actual
+    ? "provider_input_token_count"
+    : "runtime_token_estimator";
+  const usedContextPercent = contextUsedPercent(
+    inputTokens,
+    message.contextWindowTokens,
+  );
+  return {
+    inputTokens,
+    measurementKind,
+    measurement: measurementKind,
+    source,
+    contextWindowTokens: message.contextWindowTokens,
+    usedContextPercent,
+    remainingContextTokens: Math.max(
+      0,
+      message.contextWindowTokens - inputTokens,
+    ),
+    remainingContextPercent: Math.max(
+      0,
+      Math.round((100 - usedContextPercent) * 10) / 10,
+    ),
+    ...(isContextTokenCount(message.estimatedInputTokens)
+      ? { estimatedInputTokens: message.estimatedInputTokens }
+      : {}),
+    ...(actual ? { measuredInputTokens: message.measuredInputTokens } : {}),
+    metadataMismatch: hasContextMeasurementMismatch(
+      message,
+      measurementKind,
+      source,
+    ),
+  };
+}
+
+function hasContextMeasurementMismatch(message, measurement, source) {
+  if (message.measurement && message.measurement !== measurement) return true;
+  if (message.source && message.source !== source) return true;
+  return false;
+}
+
+export function normalizeContextProviderCounts(message) {
+  const counts = {};
+  for (const key of ["inputTokens", "outputTokens", "totalTokens"]) {
+    if (isContextTokenCount(message[key])) counts[key] = message[key];
+  }
+  return Object.keys(counts).length ? counts : null;
+}
+
+function isContextPercentage(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+export function selectCompactionPercentages(message) {
+  const keys = ["beforeInputTokens", "afterInputTokens", "contextWindowTokens"];
+  const hasTokenTuple = keys.some((key) => Object.hasOwn(message, key));
+  if (!hasTokenTuple) {
+    if (!isContextPercentage(message.beforeUsedContextPercent)) return null;
+    if (!isContextPercentage(message.afterUsedContextPercent)) return null;
+    return {
+      beforePercent: message.beforeUsedContextPercent,
+      afterPercent: message.afterUsedContextPercent,
+    };
+  }
+  if (!isContextTokenCount(message.beforeInputTokens)) return null;
+  if (!isContextTokenCount(message.afterInputTokens)) return null;
+  if (!isContextCapacity(message.contextWindowTokens)) return null;
+  return {
+    beforePercent: contextUsedPercent(
+      message.beforeInputTokens,
+      message.contextWindowTokens,
+    ),
+    afterPercent: contextUsedPercent(
+      message.afterInputTokens,
+      message.contextWindowTokens,
+    ),
+  };
+}

package/dist/src/web-ui/app/lib/context-window-replay.d.ts

@@ -0,0 +1,32 @@
+export type ContextReplayScope = Readonly<{
+  environmentId: string;
+  sessionId: string;
+  viewVersion: number;
+  requestId: string;
+  generation: string;
+}>;
+export declare function captureContextReplayScope(
+  state: {
+    currentSessionId: string;
+    sessionViewVersion: number;
+    requestLifecycles?: Map<string, Record<string, unknown>>;
+  },
+  environmentId: string,
+  requestId: string,
+): ContextReplayScope;
+export declare function isContextReplayCurrent(
+  scope: ContextReplayScope,
+  state: {
+    currentSessionId: string;
+    sessionViewVersion: number;
+    requestLifecycles?: Map<string, Record<string, unknown>>;
+  },
+  environmentId: string,
+): boolean;
+export declare function bindContextReplayEvents(
+  events: unknown[],
+  scope: ContextReplayScope,
+): Record<string, unknown>[];
+export declare function contextReplayBinding(
+  event: Record<string, unknown>,
+): (ContextReplayScope & { replayDomain: object; replayOrder: number }) | null;

package/dist/src/web-ui/app/lib/context-window-replay.js

@@ -0,0 +1,38 @@
+import { normalizeRealtimeMessage } from "./realtime-message.js";
+
+const replayBinding = Symbol("context replay binding");
+
+export function captureContextReplayScope(state, environmentId, requestId) {
+  return {
+    environmentId,
+    sessionId: state.currentSessionId,
+    viewVersion: state.sessionViewVersion,
+    requestId,
+    generation: state.requestLifecycles?.get(requestId)?.generation || "",
+  };
+}
+
+export function isContextReplayCurrent(scope, state, environmentId) {
+  if (scope.environmentId !== environmentId) return false;
+  if (scope.sessionId !== state.currentSessionId) return false;
+  if (scope.viewVersion !== state.sessionViewVersion) return false;
+  const generation =
+    state.requestLifecycles?.get(scope.requestId)?.generation || "";
+  return scope.generation === generation;
+}
+
+export function bindContextReplayEvents(events, scope) {
+  const replayDomain = {};
+  return events
+    .map(normalizeRealtimeMessage)
+    .filter((event) => event.requestId === scope.requestId)
+    .sort((left, right) => (left.seqNo || 0) - (right.seqNo || 0))
+    .map((event, index) => ({
+      ...event,
+      [replayBinding]: { ...scope, replayDomain, replayOrder: index + 1 },
+    }));
+}
+
+export function contextReplayBinding(event) {
+  return event[replayBinding] || null;
+}

package/dist/src/web-ui/app/lib/context-window-snapshot-order.d.ts

@@ -1,15 +1,23 @@
-interface ContextWindowSequence {
+export type ContextEvidenceOrder = {
   eventSequence?: unknown;
   seqNo?: unknown;
   lastSeqNo?: unknown;
-}
-
+  sequenceDomain?: unknown;
+  replayDomain?: unknown;
+  replayOrder?: unknown;
+};
+export declare function compareContextEvidence(
+  previous: ContextEvidenceOrder | null | undefined,
+  incoming: ContextEvidenceOrder,
+): number | null;
+export declare function hasOrderedContextEvidence(
+  event: ContextEvidenceOrder,
+): boolean;
 export declare function canReplaceContextWindowEvidence(
-  previous: ContextWindowSequence | null | undefined,
-  incoming: ContextWindowSequence,
+  previous: ContextEvidenceOrder | null | undefined,
+  incoming: ContextEvidenceOrder,
 ): boolean;
-
 export declare function isEventAfterContextWindowSnapshot(
-  snapshot: ContextWindowSequence,
-  event: ContextWindowSequence,
+  snapshot: ContextEvidenceOrder,
+  event: ContextEvidenceOrder,
 ): boolean;

package/dist/src/web-ui/app/lib/context-window-snapshot-order.js

@@ -2,30 +2,50 @@ function positiveSequence(value) {
   return Number.isSafeInteger(value) && value > 0 ? value : null;
 }
 
-function comparableSequenceDifference(previous, incoming) {
+export function compareContextEvidence(previous, incoming) {
   const previousOriginal = positiveSequence(previous?.eventSequence);
   const incomingOriginal = positiveSequence(incoming?.eventSequence);
   if (previousOriginal !== null && incomingOriginal !== null) {
     return incomingOriginal - previousOriginal;
   }
+  if (previous?.sequenceDomain !== incoming?.sequenceDomain) return null;
   const previousTransport = positiveSequence(
     previous?.seqNo ?? previous?.lastSeqNo,
   );
   const incomingTransport = positiveSequence(
     incoming?.seqNo ?? incoming?.lastSeqNo,
   );
-  if (previousTransport === null || incomingTransport === null) return null;
-  return incomingTransport - previousTransport;
+  if (previousTransport !== null && incomingTransport !== null) {
+    return incomingTransport - previousTransport;
+  }
+  if (
+    !previous?.replayDomain ||
+    previous.replayDomain !== incoming?.replayDomain
+  )
+    return null;
+  const previousReplay = positiveSequence(previous.replayOrder);
+  const incomingReplay = positiveSequence(incoming.replayOrder);
+  if (previousReplay === null || incomingReplay === null) return null;
+  return incomingReplay - previousReplay;
+}
+
+export function hasOrderedContextEvidence(event) {
+  if (positiveSequence(event?.eventSequence) !== null) return true;
+  if (positiveSequence(event?.seqNo ?? event?.lastSeqNo) !== null) return true;
+  return Boolean(
+    event?.replayDomain && positiveSequence(event.replayOrder) !== null,
+  );
 }
 
 export function canReplaceContextWindowEvidence(previous, incoming) {
-  const difference = comparableSequenceDifference(previous, incoming);
-  if (difference === null) return true;
-  return difference > 0;
+  if (!previous) return true;
+  const difference = compareContextEvidence(previous, incoming);
+  if (difference !== null) return difference > 0;
+  if (hasOrderedContextEvidence(previous)) return false;
+  return hasOrderedContextEvidence(incoming);
 }
 
 export function isEventAfterContextWindowSnapshot(snapshot, event) {
-  const difference = comparableSequenceDifference(snapshot, event);
-  if (difference === null) return false;
-  return difference > 0;
+  const difference = compareContextEvidence(snapshot, event);
+  return difference !== null && difference > 0;
 }

package/dist/src/web-ui/app/lib/context-window-state.d.ts

@@ -0,0 +1,80 @@
+import type {
+  ContextInputMeasurement,
+  ContextProviderCounts,
+} from "./context-window-measurement.js";
+import type {
+  ContextCompactionArrow,
+  ContextCompactionCycle,
+} from "./context-compaction-state.js";
+export type ContextEvidenceScope = Readonly<{
+  requestId: string;
+  environmentId: string;
+  sessionId: string;
+  viewVersion?: number;
+  generation: string;
+  generationSource?: "lifecycle" | "event" | "legacy";
+  requestKnown: boolean;
+  acceptedLifecycle?: boolean;
+}>;
+export type ContextSnapshotIdentity = Record<string, unknown> & {
+  requestId: string;
+  generation: string;
+  invocationId: string;
+  modelStep: string;
+  profileId: string;
+  admissionOutcome: string;
+};
+export type ContextSnapshotObservation = ContextSnapshotIdentity &
+  (
+    | { availability: "available"; measurement: ContextInputMeasurement }
+    | { availability: "unavailable"; measurement: null }
+  );
+export type ContextProviderUsage = ContextProviderCounts &
+  Record<string, unknown> & { invocationId: string; source: string };
+export type ContextWindowDisplay = ContextSnapshotIdentity &
+  ContextInputMeasurement & {
+    availability: "available";
+    providerUsage: ContextProviderUsage | null;
+    compaction: ContextCompactionArrow | null;
+  };
+export type ContextWindowState = Record<string, unknown> &
+  ContextEvidenceScope & {
+    latestSnapshotObservation: ContextSnapshotObservation | null;
+    lastValidSnapshot: ContextSnapshotObservation | null;
+    snapshot:
+      | (ContextSnapshotIdentity &
+          ContextInputMeasurement & { availability: "available" })
+      | null;
+    providerUsage: ContextProviderUsage | null;
+    usageByInvocation: Map<string, ContextProviderUsage>;
+    cycles: Map<string, ContextCompactionCycle>;
+    requestTerminal: Record<string, unknown> | null;
+    pendingCompaction: ContextCompactionCycle | null;
+    lastCompaction: ContextCompactionArrow | null;
+    lastCompactionEvent: Record<string, unknown> | null;
+    openCompactionCount: number;
+  };
+export declare function contextEvidenceScope(
+  state: Record<string, unknown>,
+  environmentId: string,
+  requestId: string,
+): ContextEvidenceScope;
+export declare function reduceContextWindowEvidence(
+  previous: ContextWindowState | undefined,
+  message: Record<string, unknown>,
+  scope: ContextEvidenceScope,
+): ContextWindowState | undefined;
+export declare function synchronizeContextRequestLifecycle(
+  state: Record<string, unknown>,
+  message: Record<string, unknown>,
+  environmentId: string,
+): void;
+export declare function projectContextWindowDisplay(
+  contextWindow: unknown,
+  requestId: string,
+): ContextWindowDisplay | null;
+
+export declare function contextEvidenceOrder(
+  message: Record<string, unknown>,
+  scope: ContextEvidenceScope,
+): Record<string, unknown>;