@omercnet/paseo-omp 0.4.0-next.122.1 → 0.4.0-next.124.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "0.4.0-next.122.1",
+  "version": "0.4.0-next.124.1",
   "type": "module",
   "description": "Paseo integration for OMP, including its direct provider and workspace tooling.",
   "license": "MIT",

package/server/package-version.ts

@@ -1,2 +1,2 @@
 /** Release Please keeps this bundle-safe constant aligned with package.json. */
-export const PASEO_OMP_PACKAGE_VERSION = "0.4.0-next.122.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "0.4.0-next.124.1"; // x-release-please-version

package/server/provider/session-compaction.ts

@@ -0,0 +1,187 @@
+import { randomUUID } from "node:crypto";
+import type { ProviderEvent } from "@getpaseo/plugin/server/provider";
+import type { OmpRpcEvent } from "./omp-rpc-protocol";
+import type { OmpPublicDataSerializer } from "./security";
+import type { ActiveTurn } from "./session-terminal";
+import type { OmpSessionUsage } from "./session-usage";
+import type { OmpTimelineProjector } from "./timeline-projector";
+
+type Emit = (event: ProviderEvent) => void;
+
+export interface ActiveCompaction {
+  id: string;
+  trigger: "auto" | "manual";
+  turnId: string;
+  generation: number;
+  retrying: boolean;
+  action?: string;
+  preTokens?: number;
+}
+
+export class OmpSessionCompaction {
+  private operation: ActiveCompaction | null = null;
+  private discardedEnds = 0;
+
+  constructor(
+    private readonly sessionId: string,
+    private readonly emit: Emit,
+    private readonly projector: OmpTimelineProjector,
+    private readonly dataFilter: OmpPublicDataSerializer,
+    private readonly usage: OmpSessionUsage,
+  ) {}
+
+  get active(): ActiveCompaction | null {
+    return this.operation;
+  }
+
+  start(turn: ActiveTurn, trigger: "auto" | "manual", action?: string): void {
+    if (this.discardedEnds > 0) {
+      this.discardedEnds += 1;
+      return;
+    }
+    const active = this.operation;
+    if (active && active.trigger === trigger && active.action === action) {
+      active.retrying = false;
+      return;
+    }
+    if (active) {
+      this.retire("OMP emitted overlapping compactions");
+      this.discardedEnds = 2;
+      return;
+    }
+    const operation: ActiveCompaction = {
+      id: randomUUID(),
+      trigger,
+      turnId: turn.turnId,
+      generation: turn.generation,
+      action,
+      retrying: false,
+      preTokens: this.usage.latest?.contextWindowUsedTokens,
+    };
+    this.operation = operation;
+    this.projector.flush(true);
+    this.emit({
+      type: "timeline.item",
+      sessionId: this.sessionId,
+      item: {
+        id: operation.id,
+        type: "compaction",
+        status: "loading",
+        trigger,
+        ...(operation.preTokens !== undefined ? { preTokens: operation.preTokens } : {}),
+      },
+    });
+  }
+
+  handleAutoEnd(
+    turn: ActiveTurn,
+    event: Extract<OmpRpcEvent, { type: "auto_compaction_end" }>,
+  ): boolean {
+    if (this.discardedEnds > 0) {
+      this.discardedEnds -= 1;
+      return false;
+    }
+    const operation = this.operation;
+    if (
+      operation?.trigger !== "auto" ||
+      operation.turnId !== turn.turnId ||
+      operation.generation !== turn.generation
+    ) {
+      return false;
+    }
+    if (event.action !== undefined && operation.action !== event.action) {
+      this.retire("OMP emitted overlapping compactions");
+      this.discardedEnds = 1;
+      return false;
+    }
+    if (event.willRetry) {
+      operation.retrying = true;
+      return false;
+    }
+    if (operation.retrying) {
+      operation.retrying = false;
+      return false;
+    }
+    const state = event.aborted
+      ? "canceled"
+      : event.errorMessage
+        ? "failed"
+        : event.skipped
+          ? "skipped"
+          : "completed";
+    this.finish(state, {
+      tokensBefore: event.result?.tokensBefore ?? event.result?.preTokens,
+      message: event.errorMessage,
+    });
+    return true;
+  }
+
+  finish(
+    state: "completed" | "failed" | "canceled" | "skipped",
+    options: { tokensBefore?: number | null; message?: string } = {},
+  ): void {
+    const operation = this.operation;
+    if (!operation) return;
+    this.operation = null;
+    this.projector.flush(true);
+    if (state === "completed") {
+      this.usage.completeCompaction();
+    }
+    if (state !== "completed") {
+      const defaultMessage =
+        state === "failed"
+          ? "OMP compaction failed"
+          : state === "canceled"
+            ? "OMP compaction canceled"
+            : "OMP compaction skipped";
+      this.emit({
+        type: "timeline.item",
+        sessionId: this.sessionId,
+        item: {
+          id: operation.id,
+          type: "notification",
+          level: state === "failed" ? "error" : "info",
+          message: this.dataFilter.text(options.message ?? defaultMessage, 4_096),
+        },
+      });
+      return;
+    }
+    const tokensBefore = options.tokensBefore ?? operation.preTokens;
+    this.emit({
+      type: "timeline.item",
+      sessionId: this.sessionId,
+      item: {
+        id: operation.id,
+        type: "compaction",
+        status: "completed",
+        trigger: operation.trigger,
+        ...(tokensBefore !== undefined ? { preTokens: tokensBefore } : {}),
+      },
+    });
+  }
+
+  retire(message: string): void {
+    const operation = this.operation;
+    if (!operation) return;
+    this.operation = null;
+    this.emit({
+      type: "timeline.item",
+      sessionId: this.sessionId,
+      item: {
+        id: operation.id,
+        type: "compaction",
+        status: "completed",
+        trigger: operation.trigger,
+      },
+    });
+    this.emit({
+      type: "timeline.item",
+      sessionId: this.sessionId,
+      item: { id: `${operation.id}:error`, type: "error", message },
+    });
+  }
+
+  resetDiscardedEnds(): void {
+    this.discardedEnds = 0;
+  }
+}

package/server/provider/session-events.ts

@@ -0,0 +1,42 @@
+import type { OmpRpcEvent } from "./omp-rpc-protocol";
+
+export function isNativeTurnActivity(event: OmpRpcEvent): boolean {
+  if (
+    event.type === "agent_start" ||
+    event.type === "turn_start" ||
+    event.type === "turn_end" ||
+    event.type === "agent_end" ||
+    event.type === "auto_compaction_start" ||
+    event.type === "auto_compaction_end"
+  ) {
+    return true;
+  }
+  if (
+    event.type === "message_start" ||
+    event.type === "message_update" ||
+    event.type === "message_end"
+  ) {
+    return event.message.role === "assistant";
+  }
+  return event.type.startsWith("tool_execution_");
+}
+export function isRuntimeConfigEvent(event: OmpRpcEvent): boolean {
+  return (
+    event.type === "model_changed" ||
+    event.type === "thinking_level_changed" ||
+    event.type === "retry_fallback_applied" ||
+    event.type === "retry_fallback_succeeded"
+  );
+}
+
+export function isPassiveUiMethod(method: string): boolean {
+  return (
+    method === "cancel" ||
+    method === "notify" ||
+    method === "open_url" ||
+    method === "setStatus" ||
+    method === "setWidget" ||
+    method === "setTitle" ||
+    method === "set_editor_text"
+  );
+}

package/server/provider/session-terminal.ts

@@ -0,0 +1,307 @@
+import { randomUUID } from "node:crypto";
+import type { ProviderError } from "@getpaseo/plugin/server/provider";
+import type { OmpMessage, OmpRpcEvent } from "./omp-rpc-protocol";
+
+export type PendingUser = {
+  clientMessageId: string;
+  text: string;
+  accepted: boolean;
+  fallbackOnFinish: boolean;
+  bufferedEchoes: OmpMessage[];
+};
+type TerminalCorrelationEvidence = "fresh-native-user" | "current-assistant";
+
+type TerminalCorrelation = {
+  policy: "initial-turn" | "ordered-legacy" | "native-command";
+  evidence: Map<TerminalCorrelationEvidence, number>;
+};
+
+export type TerminalCandidate = {
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>;
+  arrivalSequence: number;
+  confidence:
+    | "keyed"
+    | "initial-turn"
+    | "ordered-legacy"
+    | "native-command"
+    | "interrupted"
+    | "ambiguous";
+};
+
+export type ActiveTurn = {
+  turnId: string;
+  clientMessageId: string;
+  generation: number;
+  promptResultEmitted: boolean;
+  started: boolean;
+  terminal: boolean;
+  interrupted: boolean;
+  starting: boolean;
+  nativeActivity: boolean;
+  userEchoObserved: boolean;
+  localOnlyDisabled: boolean;
+  localOnlyEligible: boolean;
+  awaitingPermissionEvidence: boolean;
+  activitySequence: number;
+  acknowledged: boolean;
+  terminalCorrelation: TerminalCorrelation;
+  replayingBufferedEvents: boolean;
+  agentInvoked?: boolean;
+  nativeRequestId?: string;
+  promptAcceptedEventIndex?: number;
+  localOnlyTimer?: unknown;
+  usagePollTimer?: unknown;
+  usagePoll?: Promise<void>;
+  usageSampleFloor: number;
+  manualCompaction: boolean;
+  manualCompactionPending: boolean;
+  manualCompactionDeadlineTimer?: unknown;
+  agentEndPending: boolean;
+  agentEndRetryTimer?: unknown;
+  agentEndDeadlineTimer?: unknown;
+  agentEndCheck?: Promise<void>;
+  ambiguousTerminalTimer?: unknown;
+  terminalizing: boolean;
+  terminalization?: Promise<void>;
+  terminalOutcome?: TurnOutcome;
+  operationalTerminalStage?: "failed" | "unresolved";
+  terminalWake?: VoidDeferred;
+  steerReady: VoidDeferred;
+  steersInFlight: number;
+  deferredAgentEnd?: TerminalCandidate;
+  activeToolCallIds: Set<string>;
+  bufferedEvents: OmpRpcEvent[];
+  pendingUsers: PendingUser[];
+  userEchoes: OmpMessage[];
+  userCorrelationActive: boolean;
+  userLookups: Set<Promise<void>>;
+  completedMessageCount: number;
+  streamedMessageEntryIds: string[];
+  streamedMessageIdentityComplete: boolean;
+  lastCompletedAssistantOutcome?: AgentEndOutcome;
+  lastCompletedAssistantEntryId?: string;
+};
+
+export type VoidDeferred = {
+  promise: Promise<void>;
+  resolve(value?: void | PromiseLike<void>): void;
+  reject(reason?: unknown): void;
+};
+
+export type TurnOutcome = {
+  state: "completed" | "failed" | "canceled";
+  error?: ProviderError;
+  usageSampled: boolean;
+};
+
+export function nativeEntryId(message: OmpMessage): string | undefined {
+  return message.entryId;
+}
+
+export type AgentEndOutcome = "completed" | "failed" | "canceled";
+type AssistantTerminalStatus = AgentEndOutcome | "unavailable";
+
+export function assistantTerminalOutcome(
+  message: Extract<OmpMessage, { role: "assistant" }>,
+): AgentEndOutcome {
+  const stopReason = message.stopReason?.toLowerCase();
+  if (stopReason === "aborted" || stopReason === "canceled" || stopReason === "cancelled") {
+    return "canceled";
+  }
+  return stopReason === "error" || message.errorMessage ? "failed" : "completed";
+}
+
+function lastAssistantStatus(
+  messages: readonly OmpMessage[],
+  startIndex = 0,
+): AssistantTerminalStatus {
+  for (let index = messages.length - 1; index >= startIndex; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== "assistant") continue;
+    return assistantTerminalOutcome(message);
+  }
+  return "unavailable";
+}
+
+export function terminalOutcome(
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
+): AgentEndOutcome | undefined {
+  const messages = event.messages;
+  if (
+    messages !== undefined &&
+    (event.messageCount === undefined || messages.length >= event.messageCount)
+  ) {
+    const status = lastAssistantStatus(messages);
+    return status === "unavailable" ? "completed" : status;
+  }
+  if (event.messageCount === 0) return "completed";
+  if (
+    turn.lastCompletedAssistantOutcome !== undefined &&
+    (event.messageCount === undefined || turn.completedMessageCount >= event.messageCount)
+  ) {
+    return turn.lastCompletedAssistantOutcome;
+  }
+  return undefined;
+}
+
+export function historyTerminalOutcome(
+  messages: readonly OmpMessage[],
+  declaredCount: number,
+  turn: Pick<
+    ActiveTurn,
+    | "streamedMessageEntryIds"
+    | "streamedMessageIdentityComplete"
+    | "lastCompletedAssistantOutcome"
+    | "lastCompletedAssistantEntryId"
+  >,
+  retainedMessages: readonly OmpMessage[],
+): AgentEndOutcome | undefined {
+  if (
+    messages.length < declaredCount ||
+    !turn.streamedMessageIdentityComplete ||
+    turn.streamedMessageEntryIds.length === 0
+  ) {
+    return undefined;
+  }
+  const startIndex = messages.length - declaredCount;
+  let historyIndex = startIndex;
+  for (const entryId of turn.streamedMessageEntryIds) {
+    while (historyIndex < messages.length) {
+      const historyMessage = messages[historyIndex];
+      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
+      historyIndex += 1;
+    }
+    if (historyIndex >= messages.length) return undefined;
+    const correlated = messages[historyIndex];
+    if (
+      entryId === turn.lastCompletedAssistantEntryId &&
+      (correlated?.role !== "assistant" ||
+        assistantTerminalOutcome(correlated) !== turn.lastCompletedAssistantOutcome)
+    )
+      return undefined;
+    historyIndex += 1;
+  }
+  historyIndex = startIndex;
+  for (const retained of retainedMessages) {
+    const entryId = nativeEntryId(retained);
+    if (!entryId) return undefined;
+    while (historyIndex < messages.length) {
+      const historyMessage = messages[historyIndex];
+      if (historyMessage && nativeEntryId(historyMessage) === entryId) break;
+      historyIndex += 1;
+    }
+    if (historyIndex >= messages.length) return undefined;
+    const correlated = messages[historyIndex];
+    if (!correlated || correlated.role !== retained.role) return undefined;
+    if (
+      retained.role === "assistant" &&
+      correlated.role === "assistant" &&
+      assistantTerminalOutcome(retained) !== assistantTerminalOutcome(correlated)
+    )
+      return undefined;
+    historyIndex += 1;
+  }
+  const status = lastAssistantStatus(messages, startIndex);
+  return status === "unavailable" ? undefined : status;
+}
+
+export function unknownTerminalOutcomeError(
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+  turn: Pick<ActiveTurn, "completedMessageCount" | "lastCompletedAssistantOutcome">,
+): string {
+  const retainedMessages = event.messages?.length ?? 0;
+  const retainedStatus = event.messages ? lastAssistantStatus(event.messages) : "unavailable";
+  const lastStatus =
+    retainedStatus === "unavailable"
+      ? (turn.lastCompletedAssistantOutcome ?? "unavailable")
+      : retainedStatus;
+  return (
+    "OMP agent_end omitted terminal messages; outcome is unknown " +
+    `(declaredCount=${event.messageCount ?? "unavailable"}, ` +
+    `observedCount=${turn.completedMessageCount}, ` +
+    `retainedTerminalMessages=${retainedMessages}, lastAssistantStatus=${lastStatus})`
+  );
+}
+
+export function createActiveTurn(
+  clientMessageId: string,
+  text: string,
+  generation: number,
+  terminalPolicy: TerminalCorrelation["policy"],
+  manualCompaction = false,
+): ActiveTurn {
+  return {
+    turnId: randomUUID(),
+    clientMessageId,
+    agentInvoked: undefined,
+    generation,
+    promptResultEmitted: false,
+    started: false,
+    terminal: false,
+    awaitingPermissionEvidence: false,
+    interrupted: false,
+    starting: true,
+    nativeActivity: false,
+    userEchoObserved: false,
+    localOnlyDisabled: false,
+    localOnlyEligible: false,
+    usageSampleFloor: 0,
+    agentEndPending: false,
+    terminalizing: false,
+    manualCompactionPending: manualCompaction,
+    manualCompaction,
+    activitySequence: 0,
+    acknowledged: false,
+    terminalCorrelation: { policy: terminalPolicy, evidence: new Map() },
+    replayingBufferedEvents: false,
+    steersInFlight: 0,
+    activeToolCallIds: new Set(),
+    steerReady: Promise.withResolvers<void>(),
+    userCorrelationActive: false,
+    userLookups: new Set(),
+    userEchoes: [],
+    completedMessageCount: 0,
+    bufferedEvents: [],
+    streamedMessageEntryIds: [],
+    streamedMessageIdentityComplete: true,
+    pendingUsers: [
+      {
+        clientMessageId,
+        text,
+        accepted: true,
+        fallbackOnFinish: true,
+        bufferedEchoes: [],
+      },
+    ],
+  };
+}
+export function classifyTerminalCandidate(
+  turn: ActiveTurn,
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>,
+  arrivalSequence = turn.activitySequence,
+): TerminalCandidate {
+  if (event.requestId !== undefined) return { event, confidence: "keyed", arrivalSequence };
+  if (turn.agentInvoked === false) return { event, confidence: "ambiguous", arrivalSequence };
+  if (turn.terminalCorrelation.policy === "initial-turn") {
+    return { event, confidence: "initial-turn", arrivalSequence };
+  }
+  const assistantSequence = turn.terminalCorrelation.evidence.get("current-assistant");
+  if (
+    turn.terminalCorrelation.policy === "native-command" &&
+    assistantSequence !== undefined &&
+    assistantSequence <= arrivalSequence
+  ) {
+    return { event, confidence: "native-command", arrivalSequence };
+  }
+  const userSequence = turn.terminalCorrelation.evidence.get("fresh-native-user");
+  if (
+    userSequence !== undefined &&
+    assistantSequence !== undefined &&
+    userSequence < assistantSequence &&
+    assistantSequence <= arrivalSequence
+  ) {
+    return { event, confidence: "ordered-legacy", arrivalSequence };
+  }
+  return { event, confidence: "ambiguous", arrivalSequence };
+}