@omercnet/paseo-omp 0.4.0 → 1.0.0

package/server/provider/profile-providers.ts

@@ -4,7 +4,8 @@ import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
 import { isOmpProfileName } from "../../shared/omp-store";
 import { ompAgentDir, ompCacheDir, ompDataDir, ompSessionDir, ompStateDir } from "../paths";
-import { OmpRpcRuntime, type OmpRuntime, type OmpStartOptions } from "./omp-rpc";
+import { OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
+import type { OmpStartOptions } from "./omp-rpc-environment";
 import { parseOmpProviderOptions } from "./provider-options";
 import { createOmpProvider, type OmpProviderOptions } from "./registration";
 import { OmpPublicError } from "./security";

package/server/provider/prompt-payload.ts

@@ -0,0 +1,253 @@
+import type { ProviderContent, ProviderInput } from "@getpaseo/plugin/server/provider";
+import { getForgeDefinitionOrNeutral } from "@getpaseo/protocol/forge-manifest";
+import { isValidImagePayload } from "./image";
+import type { OmpImage } from "./omp-rpc-protocol";
+import { OmpPublicError, utf8Bytes } from "./security";
+
+type SessionPromptInput = Extract<ProviderInput, { type: "session.prompt" }>;
+const MAX_PROMPT_PARTS = 64;
+export const MAX_PROMPT_TEXT_LENGTH = 1024 * 1024;
+const RPC_REQUEST_ID_BYTES = 36;
+
+export function isSafeCommandName(name: string): boolean {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*(?::[A-Za-z0-9][A-Za-z0-9._-]*)*$/u.test(name);
+}
+
+export type OmpPromptPayload = { text: string; images: OmpImage[]; commandName?: string };
+export function buildOmpPromptRequest(message: string, images: readonly OmpImage[] = []) {
+  return {
+    type: "prompt" as const,
+    message,
+    streamingBehavior: "followUp" as const,
+    ...(images.length > 0 ? { images } : {}),
+  };
+}
+
+const REVIEW_LINE_MARKERS = { add: "+", remove: "-", context: " " } as const;
+
+function renderPromptAttachmentAsText(part: Exclude<ProviderContent, { type: "image" }>): string {
+  switch (part.type) {
+    case "forge_change_request": {
+      return renderChangeRequestAttachment({
+        forge: part.forge ?? "github",
+        number: part.number,
+        title: part.title,
+        url: part.url,
+        body: part.body,
+        projectPath: part.projectPath,
+        baseRefName: part.baseRefName,
+        headRefName: part.headRefName,
+      });
+    }
+    case "github_pr": {
+      return renderChangeRequestAttachment({
+        forge: "github",
+        number: part.number,
+        title: part.title,
+        url: part.url,
+        body: part.body,
+        baseRefName: part.baseRefName,
+        headRefName: part.headRefName,
+      });
+    }
+    case "forge_issue": {
+      return renderIssueAttachment({
+        forge: part.forge ?? "github",
+        number: part.number,
+        title: part.title,
+        url: part.url,
+        body: part.body,
+        projectPath: part.projectPath,
+      });
+    }
+    case "github_issue": {
+      return renderIssueAttachment({
+        forge: "github",
+        number: part.number,
+        title: part.title,
+        url: part.url,
+        body: part.body,
+      });
+    }
+    case "text": {
+      return part.text;
+    }
+    case "review": {
+      const lines = [`Paseo review attachment (${part.mode})`, `CWD: ${part.cwd}`];
+      if (part.baseRef) {
+        lines.push(`Base: ${part.baseRef}`);
+      }
+      part.comments.forEach((comment, index) => {
+        lines.push(
+          "",
+          `Comment ${index + 1}: ${comment.filePath}:${comment.side}:${comment.lineNumber}`,
+          comment.body,
+          comment.context.hunkHeader,
+        );
+        const target = comment.context.targetLine;
+        for (const line of comment.context.lines) {
+          const isTarget =
+            line.oldLineNumber === target.oldLineNumber &&
+            line.newLineNumber === target.newLineNumber &&
+            line.type === target.type &&
+            line.content === target.content;
+          const prefix = isTarget ? "> " : "  ";
+          const oldLn = padLineNumber(line.oldLineNumber);
+          const newLn = padLineNumber(line.newLineNumber);
+          lines.push(`${prefix}${oldLn} ${newLn} ${REVIEW_LINE_MARKERS[line.type]}${line.content}`);
+        }
+      });
+      return lines.join("\n");
+    }
+    case "uploaded_file": {
+      return [
+        `Uploaded file: ${part.fileName}`,
+        `Path: ${part.path}`,
+        `MIME: ${part.mimeType}`,
+        `Size: ${part.size} bytes`,
+      ].join("\n");
+    }
+    default:
+      throw new Error("unreachable");
+  }
+}
+
+function renderChangeRequestAttachment(input: {
+  forge: string;
+  number: number;
+  title: string;
+  url: string;
+  body?: string | null;
+  projectPath?: string;
+  baseRefName?: string | null;
+  headRefName?: string | null;
+}): string {
+  const lines = [
+    `${formatForgeLabel(input.forge)} ${formatChangeRequestAbbrev(input.forge)} ${formatChangeRequestNumber(input.forge, input.number)}: ${input.title}`,
+    input.url,
+  ];
+  if (input.projectPath) {
+    lines.push(`Project: ${input.projectPath}`);
+  }
+  if (input.baseRefName) {
+    lines.push(`Base: ${input.baseRefName}`);
+  }
+  if (input.headRefName) {
+    lines.push(`Head: ${input.headRefName}`);
+  }
+  if (input.body) {
+    lines.push("", input.body);
+  }
+  return lines.join("\n");
+}
+
+function renderIssueAttachment(input: {
+  forge: string;
+  number: number;
+  title: string;
+  url: string;
+  body?: string | null;
+  projectPath?: string;
+}): string {
+  const lines = [
+    `${formatForgeLabel(input.forge)} Issue ${formatIssueNumber(input.forge, input.number)}: ${input.title}`,
+    input.url,
+  ];
+  if (input.projectPath) {
+    lines.push(`Project: ${input.projectPath}`);
+  }
+  if (input.body) {
+    lines.push("", input.body);
+  }
+  return lines.join("\n");
+}
+
+function formatForgeLabel(forge: string): string {
+  return getForgeDefinitionOrNeutral(forge).displayName;
+}
+
+function formatChangeRequestAbbrev(forge: string): string {
+  return getForgeDefinitionOrNeutral(forge).changeRequestAbbrev;
+}
+
+function formatChangeRequestNumber(forge: string, number: number): string {
+  return `${getForgeDefinitionOrNeutral(forge).changeRequestNumberPrefix}${number}`;
+}
+
+function formatIssueNumber(forge: string, number: number): string {
+  return `${getForgeDefinitionOrNeutral(forge).issueNumberPrefix}${number}`;
+}
+
+function padLineNumber(lineNumber: number | null): string {
+  return (lineNumber?.toString() ?? "-").padStart(2);
+}
+
+export function promptPayload(input: SessionPromptInput): OmpPromptPayload {
+  if (input.prompt.outputSchema !== undefined || input.prompt.clearPendingPermissions) {
+    throw new OmpPublicError("OMP does not support structured output or permission controls");
+  }
+  if (input.prompt.input.type === "command") {
+    const name = input.prompt.input.name.trim();
+    if (!isSafeCommandName(name)) throw new OmpPublicError("Invalid OMP command name");
+    const argumentsText = input.prompt.input.arguments.trim();
+    const text = `/${name}${argumentsText ? ` ${argumentsText}` : ""}`;
+    if (utf8Bytes(text) > MAX_PROMPT_TEXT_LENGTH)
+      throw new OmpPublicError("OMP command is too large");
+    return { text, images: [], commandName: name };
+  }
+  if (input.prompt.input.content.length > MAX_PROMPT_PARTS) {
+    throw new OmpPublicError("OMP prompt has too many content parts");
+  }
+  const parts: string[] = [];
+  const images: OmpImage[] = [];
+  let length = 0;
+  const appendText = (text: string) => {
+    length += utf8Bytes(text) + (parts.length > 0 ? 2 : 0);
+    if (length > MAX_PROMPT_TEXT_LENGTH) throw new OmpPublicError("OMP prompt is too large");
+    parts.push(text);
+  };
+  for (const part of input.prompt.input.content) {
+    if (part.type === "text") {
+      appendText(part.text);
+      continue;
+    }
+    if (part.type === "image") {
+      if (!isValidImagePayload(part.data, part.mimeType, 8 * 1024 * 1024)) {
+        throw new OmpPublicError("OMP prompt image is invalid");
+      }
+      images.push({ type: "image", data: part.data, mimeType: part.mimeType });
+      continue;
+    }
+    appendText(renderPromptAttachmentAsText(part));
+  }
+  const text = parts.join("\n\n").trim();
+  if (!text && images.length === 0) throw new OmpPublicError("OMP prompt cannot be empty");
+  return { text, images };
+}
+
+export function inlinePromptFrameBytes(
+  payload: OmpPromptPayload,
+  delivery: "prompt" | "steer",
+): number {
+  const images = payload.images.map(({ type, mimeType }) => ({ type, data: "", mimeType }));
+  const frame =
+    delivery === "prompt"
+      ? { ...buildOmpPromptRequest(payload.text, images), id: "" }
+      : { type: "steer", message: payload.text, ...(images.length > 0 ? { images } : {}) };
+  const requestIdBytes = delivery === "prompt" ? RPC_REQUEST_ID_BYTES : 0;
+  return (
+    utf8Bytes(JSON.stringify(frame)) +
+    requestIdBytes +
+    payload.images.reduce((total, image) => total + image.data.length, 0) +
+    1
+  );
+}
+
+export function slashCommandName(text: string): string | undefined {
+  if (!text.startsWith("/")) return undefined;
+  const body = text.slice(1);
+  if (!body) return undefined;
+  const firstWhitespace = body.search(/\s/u);
+  const name = firstWhitespace === -1 ? body : body.slice(0, firstWhitespace);
+  return name || undefined;
+}

package/server/provider/registration.ts

@@ -5,9 +5,11 @@ import { z } from "zod";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import type { OmpOperationalFailureReporter } from "../operational-failure-diagnostics";
 import { probeOmpAvailability } from "../provider-diagnostics";
+import { mergeOmpInheritedEnvironmentNames } from "./config-normalization";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
-import { type OmpProtocolViolationDiagnostic, OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
+import { OmpRpcRuntime, type OmpRuntime } from "./omp-rpc";
+import type { OmpProtocolViolationDiagnostic } from "./omp-rpc-protocol";
 import { parseOmpProviderOptions } from "./provider-options";
 import { boundedJsonBytes } from "./security";
 import { OmpProviderOptionsSchema } from "./settings";
@@ -73,6 +75,7 @@ export interface OmpProviderOptions {
     options: ProviderCatalogOptionsCompat,
     timeoutMs: number | undefined,
   ) => Promise<ProviderAvailabilityCompat>;
+  resolveHostInheritEnv?: () => Promise<readonly string[]>;
 }
 
 function stableJson(value: unknown): string {
@@ -103,6 +106,10 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
     providerOptionsSchema: OmpProviderOptionsSchema,
     async getCatalogCacheKey(catalogOptions) {
       const providerOptions = parseOmpProviderOptions(catalogOptions.providerOptions);
+      const inheritEnv = mergeOmpInheritedEnvironmentNames(
+        (await options.resolveHostInheritEnv?.()) ?? [],
+        providerOptions.inheritEnv,
+      );
       // Profile providers cannot safely hash explicit environment values because they may be
       // credentials. Disable sharing for that case; otherwise retain every normalized option
       // that can change discovery alongside the fixed, non-secret store identity.
@@ -111,7 +118,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         scope: catalogOptions.scope,
         ...(catalogOptions.scope === "workspace" ? { cwd: catalogOptions.cwd } : {}),
         ...(options.catalogIdentity ? { store: options.catalogIdentity } : {}),
-        providerOptions,
+        providerOptions: { ...providerOptions, ...(inheritEnv ? { inheritEnv } : {}) },
         settings: catalogOptions.settings ?? {},
         defaultCommand: (options.environment ?? process.env).OMP_COMMAND ?? "omp",
       };
@@ -166,6 +173,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         options.browserAuthorizationRegistry,
         undefined,
         options.reportOperationalFailure,
+        options.resolveHostInheritEnv,
       );
     },
   };

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-descriptors.ts

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { constants, type Dir } from "node:fs";
 import { type FileHandle, lstat, open, opendir, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { basename, isAbsolute, join, relative, resolve } from "node:path";
 import { ompSessionDir } from "../paths";
 import { isValidImagePayload } from "./image";
 
@@ -510,16 +510,19 @@ interface PersistedTranscriptNode {
   message?: unknown;
 }
 
-function persistedTranscriptMessage(record: Record<string, unknown>, entryId: string): unknown {
+function persistedTranscriptMessage(record: Record<string, unknown>, entryId?: string): unknown {
   if (record.type === "message") {
     if (!record.message || typeof record.message !== "object" || Array.isArray(record.message))
       return;
-    return { ...(record.message as Record<string, unknown>), entryId };
+    return {
+      ...(record.message as Record<string, unknown>),
+      ...(entryId ? { entryId } : {}),
+    };
   }
   if (record.type !== "custom_message") return;
   return {
     role: "custom",
-    entryId,
+    ...(entryId ? { entryId } : {}),
     customType: record.customType,
     content: record.content,
     display: record.display,
@@ -680,6 +683,7 @@ export async function readOmpPersistedSubagentTranscript(
   childTranscriptId: string,
   cwd: string,
   signal?: AbortSignal,
+  childSessionFile?: string,
 ): Promise<OmpPersistedSubagentTranscript> {
   signal?.throwIfAborted();
   if (
@@ -687,7 +691,12 @@ export async function readOmpPersistedSubagentTranscript(
     !parentSessionFile.endsWith(".jsonl") ||
     parentSessionFile.includes("\0") ||
     !CHILD_TRANSCRIPT_ID.test(childTranscriptId) ||
-    basename(childTranscriptId) !== childTranscriptId
+    basename(childTranscriptId) !== childTranscriptId ||
+    (childSessionFile !== undefined &&
+      (!isAbsolute(childSessionFile) ||
+        !childSessionFile.endsWith(".jsonl") ||
+        childSessionFile.includes("\0") ||
+        basename(childSessionFile) !== `${childTranscriptId}.jsonl`))
   ) {
     throw new Error("Invalid OMP child transcript descriptor");
   }
@@ -707,34 +716,53 @@ export async function readOmpPersistedSubagentTranscript(
     await parentHandle.close().catch(() => undefined);
   }
   const canonicalParent = await realpath(parentSessionFile);
-  const parentExtension = extname(canonicalParent);
-  const expectedDirectory = canonicalParent.slice(0, -parentExtension.length);
+  const expectedDirectory = canonicalParent.slice(0, -".jsonl".length);
   const canonicalDirectory = await realpath(expectedDirectory).catch(() => undefined);
   if (!canonicalDirectory || canonicalDirectory !== expectedDirectory) {
     throw new Error("OMP child transcript directory is not canonically owned by its parent");
   }
-  const sessionFile = join(canonicalDirectory, `${childTranscriptId}.jsonl`);
+  const requestedFile = resolve(
+    childSessionFile ?? join(canonicalDirectory, `${childTranscriptId}.jsonl`),
+  );
   let handle: FileHandle;
   try {
     handle = await open(
-      sessionFile,
+      requestedFile,
       constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0),
     );
   } catch {
     throw new Error("OMP child transcript could not be opened");
   }
   try {
-    const [stat, canonicalChild] = await Promise.all([handle.stat(), realpath(sessionFile)]);
+    const [stat, pathStat, canonicalChild] = await Promise.all([
+      handle.stat(),
+      lstat(requestedFile),
+      realpath(requestedFile),
+    ]);
     if (
       !stat.isFile() ||
-      stat.size > MAX_CHILD_TRANSCRIPT_BYTES ||
-      dirname(canonicalChild) !== canonicalDirectory ||
-      canonicalChild !== sessionFile
+      !pathStat.isFile() ||
+      pathStat.isSymbolicLink() ||
+      stat.dev !== pathStat.dev ||
+      stat.ino !== pathStat.ino ||
+      stat.size > MAX_CHILD_TRANSCRIPT_BYTES
     ) {
       throw new Error("OMP child transcript failed ownership validation");
     }
-    const bytes = await handle.readFile();
-    signal?.throwIfAborted();
+    const canonicalRelativeChild = relative(canonicalDirectory, canonicalChild);
+    if (
+      !canonicalRelativeChild ||
+      canonicalRelativeChild.startsWith("..") ||
+      isAbsolute(canonicalRelativeChild)
+    ) {
+      throw new Error("OMP child transcript failed ownership validation");
+    }
+    const bytes = await readStableFile(
+      handle,
+      stat.size,
+      signal,
+      "OMP child transcript changed while reading",
+    );
     const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     const messages: unknown[] = [];
     let nativeSessionId: string | undefined;
@@ -752,15 +780,21 @@ export async function readOmpPersistedSubagentTranscript(
         nativeSessionId ??= candidateId;
         if (nativeSessionId !== candidateId)
           throw new Error("OMP child transcript identity changed");
-      } else if (record.type === "message" && record.message !== undefined) {
+      } else {
+        const entryId =
+          typeof record.id === "string" && CHILD_TRANSCRIPT_ID.test(record.id)
+            ? record.id
+            : undefined;
+        const message = persistedTranscriptMessage(record, entryId);
+        if (message === undefined) continue;
         if (messages.length >= MAX_CHILD_TRANSCRIPT_MESSAGES) {
           throw new Error("OMP child transcript exceeds message limits");
         }
-        messages.push(record.message);
+        messages.push(message);
       }
     }
     if (!nativeSessionId) throw new Error("OMP child transcript is missing session identity");
-    return { sessionFile, nativeSessionId, byteLength: bytes.byteLength, messages };
+    return { sessionFile: canonicalChild, nativeSessionId, byteLength: bytes.byteLength, messages };
   } catch (error) {
     if (error instanceof Error) throw error;
     throw new Error("OMP child transcript could not be decoded");

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"
+  );
+}