@omercnet/paseo-omp 0.2.1 → 0.3.0-next.100.1

package/server/provider/omp-rpc.ts

@@ -2,12 +2,20 @@ import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { isAbsolute, join } from "node:path";
 import { z } from "zod";
+import { ompDataDir } from "../paths";
 import { isValidImagePayload } from "./image";
-import { boundedJsonBytes, OmpCleanupFailure, OmpPublicError, utf8Bytes } from "./security";
+import {
+  boundedJsonBytes,
+  boundedJsonMetrics,
+  OmpCleanupFailure,
+  OmpPublicError,
+  utf8Bytes,
+} from "./security";
 import {
   listOmpSessionDescriptors,
   type OmpSessionDescriptor,
   type OmpSessionListOptions,
+  readOmpPersistedSessionTranscript,
   readOmpPersistedSubagentTranscript,
   validateNativeSessionId,
 } from "./session-descriptors";
@@ -54,7 +62,17 @@ const MAX_PENDING_ONE_WAY_WRITES = 256;
 const MAX_PENDING_WRITE_BYTES = 8 * 1024 * 1024;
 const MAX_LINE_PARTS = 4_096;
 const MAX_ARRAY_ITEMS = 512;
-const MAX_CONTENT_PARTS = 64;
+// OMP read metadata can contain one source entry per displayed line. Bound this optional,
+// opaque field separately so over-budget metadata can be omitted without losing completion events.
+const MAX_OPTIONAL_METADATA_BYTES = MAX_TOOL_PAYLOAD_LENGTH;
+const MAX_OPTIONAL_METADATA_ITEMS = 2_048;
+const MAX_OPTIONAL_METADATA_NODES = 4_096;
+const MAX_TASK_CORRELATION_BYTES = 256 * 1024;
+const MAX_TASK_CORRELATION_ITEMS = 1_024;
+const MAX_TASK_CORRELATION_NODES = 4_096;
+// Tool-intensive OMP turns legitimately exceed 64 blocks; transport byte/node budgets remain the
+// primary resource bounds.
+export const OMP_MAX_CONTENT_PARTS = 4_096;
 const MAX_TODOS = 256;
 const MAX_ENV_ENTRIES = 256;
 const MAX_ENV_VALUE_LENGTH = 64 * 1024;
@@ -63,6 +81,9 @@ const MAX_PATH_LENGTH = 4_096;
 const WINDOWS_DEFAULT_SYSTEM_ROOT = "C:\\Windows";
 const MAX_TOKEN_COUNT = Number.MAX_SAFE_INTEGER;
 const MAX_COST_USD = 1_000_000_000;
+const MAX_RPC_ERROR_BYTES = 4_096;
+const MAX_RPC_ERROR_CODE_BYTES = 256;
+const PROMPT_SCHEDULING_FAILURE = "OMP prompt scheduling failed";
 const MAX_CONTEXT_PERCENT = 1_000_000;
 function boundedJsonString(maxBytes: number, minBytes = 0) {
   return z.string().refine((value) => {
@@ -99,6 +120,76 @@ const IDENTIFIER = boundedString(MAX_ID_LENGTH, 1);
 const NAME = boundedString(MAX_NAME_LENGTH, 1);
 const OMP_PROVIDER_NAME = NAME.refine((provider) => !provider.includes("/"));
 const TEXT = boundedString(MAX_TEXT_LENGTH);
+const RAW_DISPLAY_TEXT = boundedString(MAX_IMAGE_DATA_LENGTH);
+const DISPLAY_TRUNCATION_MARKER = "<truncated>";
+
+function boundRawDisplayContent(value: unknown): unknown {
+  if (typeof value === "string") {
+    return utf8Bytes(value) <= MAX_IMAGE_DATA_LENGTH ? value : DISPLAY_TRUNCATION_MARKER;
+  }
+  if (!Array.isArray(value)) return value;
+  let totalBytes = 0;
+  for (const part of value) {
+    if (!part || typeof part !== "object" || Array.isArray(part)) continue;
+    const record = part as Record<string, unknown>;
+    if (typeof record.text === "string") totalBytes += utf8Bytes(record.text);
+    if (typeof record.thinking === "string") totalBytes += utf8Bytes(record.thinking);
+  }
+  if (totalBytes <= MAX_IMAGE_DATA_LENGTH) return value;
+
+  let retainedMarker = false;
+  return value.map((part) => {
+    if (!part || typeof part !== "object" || Array.isArray(part)) return part;
+    const copy = { ...(part as Record<string, unknown>) };
+    for (const key of ["text", "thinking"] as const) {
+      if (typeof copy[key] !== "string") continue;
+      if (retainedMarker) delete copy[key];
+      else {
+        copy[key] = DISPLAY_TRUNCATION_MARKER;
+        retainedMarker = true;
+      }
+    }
+    return copy;
+  });
+}
+
+function sanitizeLiveMessageDisplay(value: unknown): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const message = value as Record<string, unknown>;
+  if (message.role === "assistant") {
+    const content = boundRawDisplayContent(message.content);
+    return content === message.content ? value : { ...message, content };
+  }
+  if (
+    message.role === "bashExecution" &&
+    typeof message.output === "string" &&
+    utf8Bytes(message.output) > MAX_IMAGE_DATA_LENGTH
+  ) {
+    return { ...message, output: DISPLAY_TRUNCATION_MARKER };
+  }
+  return value;
+}
+
+function sanitizeLiveDisplayFrame(value: unknown): unknown {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const frame = value as Record<string, unknown>;
+  if (
+    frame.type === "message_start" ||
+    frame.type === "message_update" ||
+    frame.type === "message_end"
+  ) {
+    const message = sanitizeLiveMessageDisplay(frame.message);
+    return message === frame.message ? value : { ...frame, message };
+  }
+  if (frame.type !== "agent_end" || !Array.isArray(frame.messages)) return value;
+  let changed = false;
+  const messages = frame.messages.map((message) => {
+    const sanitized = sanitizeLiveMessageDisplay(message);
+    if (sanitized !== message) changed = true;
+    return sanitized;
+  });
+  return changed ? { ...frame, messages } : value;
+}
 const OmpThinkingLevelSchema = z.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 function isBoundedJson(
@@ -111,6 +202,148 @@ function isBoundedJson(
     boundedJsonBytes(value, maxBytes, maxItems, maxBytes, maxNodes) !== Number.POSITIVE_INFINITY
   );
 }
+function optionalMetadataMetrics(value: unknown) {
+  return boundedJsonMetrics(
+    value,
+    MAX_OPTIONAL_METADATA_BYTES,
+    MAX_OPTIONAL_METADATA_ITEMS,
+    MAX_OPTIONAL_METADATA_BYTES,
+    MAX_OPTIONAL_METADATA_NODES,
+  );
+}
+
+function optionalMetadataIsBounded(value: unknown): boolean {
+  return optionalMetadataMetrics(value) !== undefined;
+}
+
+function omitUnsafeOptionalDetails(value: unknown): unknown {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value as Record<string, unknown>;
+  if (!Object.hasOwn(record, "details") || optionalMetadataIsBounded(record.details)) return value;
+  const { details: _details, ...safe } = record;
+  return safe;
+}
+
+const TASK_RESULT_STATUSES: Readonly<Record<string, true>> = {
+  pending: true,
+  running: true,
+  completed: true,
+  failed: true,
+  error: true,
+  aborted: true,
+  canceled: true,
+  cancelled: true,
+};
+const TASK_PROGRESS_STATUSES: Readonly<Record<string, true>> = {
+  pending: true,
+  running: true,
+  completed: true,
+  failed: true,
+  aborted: true,
+};
+
+function boundedTaskId(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && utf8Bytes(value) <= MAX_ID_LENGTH;
+}
+
+function taskCorrelationDetails(value: unknown): unknown {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return;
+  const details = value as Record<string, unknown>;
+  if (!Array.isArray(details.results) || details.results.length > MAX_TASK_CORRELATION_ITEMS)
+    return;
+  const results: Record<string, unknown>[] = [];
+  for (const value of details.results) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return;
+    const result = value as Record<string, unknown>;
+    if (!boundedTaskId(result.id)) return;
+    const safe: Record<string, unknown> = { id: result.id };
+    if (typeof result.status === "string" && Object.hasOwn(TASK_RESULT_STATUSES, result.status)) {
+      safe.status = result.status;
+    }
+    if (typeof result.aborted === "boolean") safe.aborted = result.aborted;
+    if (typeof result.exitCode === "number" && Number.isFinite(result.exitCode)) {
+      safe.exitCode = result.exitCode;
+    }
+    if (
+      result.error !== undefined &&
+      boundedJsonMetrics(result.error, 4_096, 32, 4_096, 64) !== undefined
+    ) {
+      safe.error = result.error;
+    }
+    results.push(safe);
+  }
+  let progress: Record<string, unknown>[] | undefined;
+  if (details.progress !== undefined) {
+    if (!Array.isArray(details.progress) || details.progress.length > MAX_TASK_CORRELATION_ITEMS) {
+      return;
+    }
+    progress = [];
+    for (const value of details.progress) {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) return;
+      const item = value as Record<string, unknown>;
+      if (
+        !boundedTaskId(item.id) ||
+        typeof item.index !== "number" ||
+        !Number.isInteger(item.index) ||
+        item.index < 0 ||
+        item.index >= MAX_TASK_CORRELATION_ITEMS ||
+        typeof item.status !== "string" ||
+        !Object.hasOwn(TASK_PROGRESS_STATUSES, item.status)
+      ) {
+        return;
+      }
+      progress.push({ id: item.id, index: item.index, status: item.status });
+    }
+  }
+  const correlation = { results, ...(progress ? { progress } : {}) };
+  return boundedJsonMetrics(
+    correlation,
+    MAX_TASK_CORRELATION_BYTES,
+    MAX_TASK_CORRELATION_ITEMS,
+    MAX_TASK_CORRELATION_BYTES,
+    MAX_TASK_CORRELATION_NODES,
+  )
+    ? correlation
+    : undefined;
+}
+
+function omitOptionalDetails(value: unknown, preserveTaskCorrelation = false): unknown {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  const record = value as Record<string, unknown>;
+  if (!Object.hasOwn(record, "details")) return value;
+  const { details: _details, ...structural } = record;
+  if (!preserveTaskCorrelation) return structural;
+  const correlation = taskCorrelationDetails(record.details);
+  return correlation === undefined ? structural : { ...structural, details: correlation };
+}
+
+function createOptionalMetadataSanitizer(): (value: unknown, taskResult?: boolean) => unknown {
+  let retainedBytes = 0;
+  let retainedNodes = 0;
+  return (value, taskResult = false) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+    const record = value as Record<string, unknown>;
+    if (!Object.hasOwn(record, "details")) return value;
+    const metrics = optionalMetadataMetrics(record.details);
+    if (
+      metrics &&
+      retainedBytes + metrics.bytes <= MAX_OPTIONAL_METADATA_BYTES &&
+      retainedNodes + metrics.nodes <= MAX_OPTIONAL_METADATA_NODES
+    ) {
+      retainedBytes += metrics.bytes;
+      retainedNodes += metrics.nodes;
+      return value;
+    }
+    const correlation = taskResult ? taskCorrelationDetails(record.details) : undefined;
+    const { details: _details, ...safe } = record;
+    return correlation === undefined ? safe : { ...safe, details: correlation };
+  };
+}
+
+const OmpOptionalMetadataSchema = z.preprocess(
+  (value) => (optionalMetadataIsBounded(value) ? value : undefined),
+  z.unknown().optional(),
+);
 
 const OmpContentPartSchema = z
   .object({
@@ -140,13 +373,21 @@ const OmpContentPartSchema = z
       context.addIssue({ code: "custom", message: "invalid image payload" });
     }
   });
+const OmpAssistantContentPartSchema = OmpContentPartSchema.safeExtend({
+  text: RAW_DISPLAY_TEXT.optional(),
+  thinking: RAW_DISPLAY_TEXT.optional(),
+});
+const OmpAssistantDisplayContentSchema = z.preprocess(
+  boundRawDisplayContent,
+  z.union([RAW_DISPLAY_TEXT, z.array(OmpAssistantContentPartSchema).max(OMP_MAX_CONTENT_PARTS)]),
+);
 const OmpDisplayContentSchema = z.union([
   TEXT,
-  z.array(OmpContentPartSchema).max(MAX_CONTENT_PARTS),
+  z.array(OmpContentPartSchema).max(OMP_MAX_CONTENT_PARTS),
 ]);
 const OmpImageArraySchema = z
   .array(OmpContentPartSchema)
-  .max(MAX_CONTENT_PARTS)
+  .max(OMP_MAX_CONTENT_PARTS)
   .superRefine((parts, context) => {
     if (parts.some((part) => part.type !== "image")) {
       context.addIssue({ code: "custom", message: "invalid image collection" });
@@ -158,10 +399,7 @@ const OmpMessageIdentityShape = {
   responseId: IDENTIFIER.optional(),
   images: OmpImageArraySchema.optional(),
   timestamp: z.number().finite().optional(),
-  details: z
-    .unknown()
-    .refine((value) => isBoundedJson(value, MAX_SEMANTIC_FRAME_BYTES, 1_024, 4_096))
-    .optional(),
+  details: OmpOptionalMetadataSchema,
 };
 type OmpContentPart = z.infer<typeof OmpContentPartSchema>;
 type OmpMessageIdentity = {
@@ -211,7 +449,7 @@ export type OmpMessage = OmpMessageIdentity &
 const OmpMessageSchema: z.ZodType<OmpMessage> = z.union([
   z.object({
     role: z.literal("assistant"),
-    content: OmpDisplayContentSchema.optional(),
+    content: OmpAssistantDisplayContentSchema.optional(),
     ...OmpMessageIdentityShape,
     errorMessage: boundedString(4_096).nullable().optional(),
     stopReason: boundedString(64).optional(),
@@ -234,7 +472,13 @@ const OmpMessageSchema: z.ZodType<OmpMessage> = z.union([
   z.object({
     role: z.literal("bashExecution"),
     command: TEXT,
-    output: TEXT.optional(),
+    output: z.preprocess(
+      (value) =>
+        typeof value === "string" && utf8Bytes(value) > MAX_IMAGE_DATA_LENGTH
+          ? DISPLAY_TRUNCATION_MARKER
+          : value,
+      RAW_DISPLAY_TEXT.optional(),
+    ),
     exitCode: z.number().int().nullable().optional(),
     cancelled: z.boolean().optional(),
     truncated: z.boolean().optional(),
@@ -259,7 +503,7 @@ const OmpAssistantMessageEventSchema = z
       .number()
       .int()
       .nonnegative()
-      .max(MAX_CONTENT_PARTS - 1)
+      .max(OMP_MAX_CONTENT_PARTS - 1)
       .optional(),
     delta: TEXT.optional(),
     content: z
@@ -387,7 +631,8 @@ const OmpResponseFrameSchema = z.object({
   id: IDENTIFIER,
   success: z.boolean(),
   data: z.unknown().optional(),
-  error: boundedString(4_096).optional(),
+  error: boundedString(MAX_RPC_ERROR_BYTES).optional(),
+  code: boundedString(MAX_RPC_ERROR_CODE_BYTES, 1).optional(),
 });
 const OmpChunkFrameSchema = z.object({
   type: z.literal("rpc_chunk"),
@@ -401,6 +646,16 @@ const JsonObjectSchema = z.record(z.string(), z.unknown());
 const BoundedToolPayloadSchema = z
   .unknown()
   .refine((value) => isBoundedJson(value, MAX_SEMANTIC_FRAME_BYTES, 1_024, 4_096));
+const OmpToolResultPayloadSchema = z.preprocess(
+  omitUnsafeOptionalDetails,
+  z
+    .unknown()
+    .refine(
+      (value) =>
+        isBoundedJson(value, MAX_SEMANTIC_FRAME_BYTES, MAX_OPTIONAL_METADATA_ITEMS, 8_192) &&
+        isBoundedJson(omitOptionalDetails(value), MAX_SEMANTIC_FRAME_BYTES, 1_024, 4_096),
+    ),
+);
 const OmpHostToolDefinitionSchema = z.object({
   name: NAME,
   label: NAME.optional(),
@@ -562,6 +817,7 @@ const OmpToolApprovalResponseSchema = z.union([
 ]);
 const OmpAgentEndEnvelopeSchema = z.object({
   type: z.literal("agent_end"),
+  requestId: IDENTIFIER.optional(),
   messageCount: z.number().int().nonnegative().optional(),
   isTerminal: z.boolean().optional(),
 });
@@ -582,6 +838,7 @@ const OmpAgentSessionEventSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("agent_start") }),
   z.object({
     type: z.literal("agent_end"),
+    requestId: IDENTIFIER.optional(),
     messages: z.array(OmpMessageSchema).max(MAX_ARRAY_ITEMS).optional(),
     messageCount: z.number().int().nonnegative().optional(),
     isTerminal: z.boolean().optional(),
@@ -606,13 +863,13 @@ const OmpAgentSessionEventSchema = z.discriminatedUnion("type", [
     toolCallId: IDENTIFIER,
     toolName: NAME,
     args: BoundedToolPayloadSchema.optional(),
-    partialResult: BoundedToolPayloadSchema,
+    partialResult: OmpToolResultPayloadSchema,
   }),
   z.object({
     type: z.literal("tool_execution_end"),
     toolCallId: IDENTIFIER,
     toolName: NAME,
-    result: BoundedToolPayloadSchema,
+    result: OmpToolResultPayloadSchema,
     isError: z.boolean().optional(),
   }),
   OmpCompactionStartSchema,
@@ -863,6 +1120,102 @@ const OmpRuntimeEventSchema = z.discriminatedUnion("type", [
   OmpToolApprovalCancelSchema,
   z.object({ type: z.literal("advisor_yielded") }),
 ]);
+type OptionalDetailsMapper = (value: unknown, taskResult?: boolean) => unknown;
+
+function mapRecordField(
+  record: Record<string, unknown>,
+  key: string,
+  map: OptionalDetailsMapper,
+  taskResult = false,
+): Record<string, unknown> {
+  if (!Object.hasOwn(record, key)) return record;
+  const next = map(record[key], taskResult);
+  return next === record[key] ? record : { ...record, [key]: next };
+}
+
+function mapMessageList(value: unknown, map: OptionalDetailsMapper): unknown {
+  if (!Array.isArray(value)) return value;
+  let changed = false;
+  const messages = value.map((message) => {
+    const taskResult =
+      message !== null &&
+      typeof message === "object" &&
+      !Array.isArray(message) &&
+      (message as Record<string, unknown>).role === "toolResult" &&
+      (message as Record<string, unknown>).toolName === "task";
+    const next = map(message, taskResult);
+    changed ||= next !== message;
+    return next;
+  });
+  return changed ? messages : value;
+}
+
+function mapAgentEventDetails(
+  frame: Record<string, unknown>,
+  map: OptionalDetailsMapper,
+): Record<string, unknown> {
+  switch (frame.type) {
+    case "message_start":
+    case "message_update":
+    case "message_end": {
+      const message = frame.message;
+      const taskResult =
+        message !== null &&
+        typeof message === "object" &&
+        !Array.isArray(message) &&
+        (message as Record<string, unknown>).role === "toolResult" &&
+        (message as Record<string, unknown>).toolName === "task";
+      return mapRecordField(frame, "message", map, taskResult);
+    }
+    case "tool_execution_update":
+      return mapRecordField(frame, "partialResult", map, frame.toolName === "task");
+    case "tool_execution_end":
+      return mapRecordField(frame, "result", map, frame.toolName === "task");
+    case "agent_end":
+      return mapRecordField(frame, "messages", (messages) => mapMessageList(messages, map));
+    default:
+      return frame;
+  }
+}
+
+function mapRuntimeFrameDetails(
+  frame: Record<string, unknown>,
+  map: OptionalDetailsMapper,
+): Record<string, unknown> {
+  if (frame.type !== "subagent_event") return mapAgentEventDetails(frame, map);
+  if (frame.payload === null || typeof frame.payload !== "object" || Array.isArray(frame.payload)) {
+    return frame;
+  }
+  const payload = frame.payload as Record<string, unknown>;
+  if (payload.event === null || typeof payload.event !== "object" || Array.isArray(payload.event)) {
+    return frame;
+  }
+  const event = mapAgentEventDetails(payload.event as Record<string, unknown>, map);
+  return event === payload.event ? frame : { ...frame, payload: { ...payload, event } };
+}
+
+function sanitizeMessageListMetadata(value: unknown): unknown {
+  return mapMessageList(value, createOptionalMetadataSanitizer());
+}
+
+function sanitizeHistoryResponseData(value: unknown): unknown {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  return mapRecordField(value as Record<string, unknown>, "messages", sanitizeMessageListMetadata);
+}
+
+function runtimeFrameCollectionLimit(frame: Record<string, unknown>): number {
+  const type = frame.type;
+  if (
+    type === "message_start" ||
+    type === "message_update" ||
+    type === "message_end" ||
+    type === "agent_end" ||
+    type === "subagent_event"
+  ) {
+    return OMP_MAX_CONTENT_PARTS;
+  }
+  return 1_024;
+}
 const OmpModelsResultSchema = z.object({
   models: z.array(OmpModelSchema).min(1).max(256),
 });
@@ -924,7 +1277,7 @@ export function parseOmpHostToolAgentResult(value: unknown): OmpHostToolResult["
 }
 export type OmpRpcEvent =
   | z.infer<typeof OmpRuntimeEventSchema>
-  | { type: "prompt_error"; id: string; error: string }
+  | { type: "prompt_error"; id: string; error: string; code?: string }
   | { type: "process_exit"; error: string };
 export type OmpAgentSessionEvent = z.infer<typeof OmpAgentSessionEventSchema>;
 export type OmpSubagentSnapshot = z.infer<typeof OmpSubagentsResultSchema>["subagents"][number];
@@ -945,6 +1298,12 @@ export interface OmpPersistedSubagentMessages {
   byteLength: number;
   messages: OmpMessage[];
 }
+export interface OmpPersistedSessionMessages {
+  sessionFile: string;
+  nativeSessionId: string;
+  byteLength: number;
+  messages: OmpMessage[];
+}
 
 export interface OmpStartOptions {
   cwd: string;
@@ -997,6 +1356,7 @@ export interface OmpRuntimeSession {
     message: string,
     images?: readonly OmpImage[],
     onAccepted?: () => void,
+    onRequested?: (requestId: string) => void,
   ): Promise<{ requestId: string; agentInvoked?: boolean }>;
   compact(customInstructions?: string): Promise<OmpCompactionResult>;
   setAutoCompaction(enabled: boolean): Promise<void>;
@@ -1022,6 +1382,12 @@ export interface OmpRuntime {
   readonly supportsPersistence: boolean;
   startSession(options: OmpStartOptions): Promise<OmpRuntimeSession>;
   listSessions(options: OmpSessionListOptions): Promise<OmpSessionDescriptor[]>;
+  readPersistedSessionTranscript?(options: {
+    sessionFile: string;
+    sessionId: string;
+    cwd: string;
+    signal?: AbortSignal;
+  }): Promise<OmpPersistedSessionMessages>;
   readPersistedSubagentTranscript(options: {
     parentSessionFile: string;
     childTranscriptId: string;
@@ -1965,21 +2331,7 @@ class OmpRpcProcess {
       this.recordProtocolViolation();
       return;
     }
-    if (this.receiveKnownResponse(decoded)) return;
-    if (this.receiveDegradedAgentEnd(decoded, true)) return;
-    if (
-      boundedJsonBytes(decoded, MAX_SEMANTIC_FRAME_BYTES, 1_024, MAX_IMAGE_DATA_LENGTH, 4_096) ===
-      Number.POSITIVE_INFINITY
-    ) {
-      this.recordProtocolViolation();
-      return;
-    }
-    const frame = JsonObjectSchema.safeParse(decoded);
-    if (!frame.success) {
-      this.recordProtocolViolation();
-      return;
-    }
-    this.receiveFrame(frame.data);
+    this.receiveDecodedFrame(decoded, payload.byteLength);
   }
 
   private receiveChunk(frame: ChunkFrame): void {
@@ -2049,32 +2401,43 @@ class OmpRpcProcess {
       this.recordProtocolViolation();
       return;
     }
-    if (this.receiveKnownResponse(decodedFrame)) return;
-    if (this.receiveDegradedAgentEnd(decodedFrame, true)) return;
-    if (
-      boundedJsonBytes(
-        decodedFrame,
-        MAX_SEMANTIC_FRAME_BYTES,
-        1_024,
-        MAX_IMAGE_DATA_LENGTH,
-        4_096,
-      ) === Number.POSITIVE_INFINITY
-    ) {
-      this.recordProtocolViolation();
+    this.receiveDecodedFrame(decodedFrame, reassembled.byteLength);
+  }
+
+  private receiveDecodedFrame(value: unknown, rawByteLength: number): void {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const frame = value as Record<string, unknown>;
+      const pending = typeof frame.id === "string" ? this.pending.get(frame.id) : undefined;
+      if (
+        frame.type === "response" &&
+        (pending?.command === "get_messages" || pending?.command === "get_subagent_messages")
+      ) {
+        this.receiveResponse(frame);
+        return;
+      }
+    }
+    if (rawByteLength > MAX_SEMANTIC_FRAME_BYTES) {
+      this.fail(new Error("OMP RPC frame exceeds the semantic byte limit"));
       return;
     }
-    const frameObject = JsonObjectSchema.safeParse(decodedFrame);
-    if (!frameObject.success) {
+    if (this.receiveKnownResponse(value)) return;
+    const sanitized = sanitizeLiveDisplayFrame(value);
+    const frame = JsonObjectSchema.safeParse(sanitized);
+    if (!frame.success) {
       this.recordProtocolViolation();
       return;
     }
-    this.receiveFrame(frameObject.data);
+    this.receiveFrame(frame.data);
   }
 
   private receiveKnownResponse(value: unknown): boolean {
     if (!value || typeof value !== "object" || Array.isArray(value)) return false;
     const frame = value as Record<string, unknown>;
-    if (frame.type !== "response" || typeof frame.id !== "string" || !this.pending.has(frame.id)) {
+    if (
+      frame.type !== "response" ||
+      typeof frame.id !== "string" ||
+      (!this.pending.has(frame.id) && !this.acceptedPromptIds.has(frame.id))
+    ) {
       return false;
     }
     this.receiveResponse(frame);
@@ -2088,34 +2451,43 @@ class OmpRpcProcess {
     if (!response.success) {
       if (rawId && knownPending) {
         this.takePending(rawId)?.reject(new Error("OMP RPC response is invalid"));
-      } else {
+      } else if (!rawId || !this.emitAcceptedPromptFailure(rawId, frame)) {
         this.recordProtocolViolation();
       }
       return;
     }
     const pending = this.pending.get(response.data.id);
     if (!pending) {
-      if (!response.data.success && this.acceptedPromptIds.delete(response.data.id)) {
-        this.emit({
-          type: "prompt_error",
-          id: response.data.id,
-          error: "OMP prompt scheduling failed",
-        });
+      if (!response.data.success) {
+        this.emitAcceptedPromptFailure(response.data.id, response.data);
       }
       return;
     }
     const isBranchHistory = pending.command === "get_branch_messages";
     const isHistory =
       pending.command === "get_messages" || pending.command === "get_subagent_messages";
+    const responseData = isHistory
+      ? sanitizeHistoryResponseData(response.data.data)
+      : response.data.data;
+    const boundedFrame =
+      responseData === response.data.data ? frame : { ...frame, data: responseData };
     const responseItemLimit = isBranchHistory ? 1_024 : isHistory ? 100_000 : MAX_ARRAY_ITEMS;
     const responseByteLimit =
       isBranchHistory || isHistory
         ? Math.min(MAX_REASSEMBLED_FRAME_BYTES, this.reassembledFrameLimit)
         : 2 * 1024 * 1024;
-    const responseNodeLimit = isBranchHistory ? 4_096 : isHistory ? 400_000 : 2_048;
+    // A model catalog contains up to 256 structured models, so its aggregate
+    // node budget must exceed the small state/command-response budget.
+    const responseNodeLimit = isBranchHistory
+      ? 4_096
+      : isHistory
+        ? 400_000
+        : pending.command === "get_available_models"
+          ? 16_384
+          : 2_048;
     if (
       boundedJsonBytes(
-        frame,
+        boundedFrame,
         responseByteLimit,
         responseItemLimit,
         MAX_IMAGE_DATA_LENGTH,
@@ -2131,7 +2503,7 @@ class OmpRpcProcess {
     if (!settled) return;
     if (response.data.success) {
       try {
-        settled.beforeResolve?.(response.data.data);
+        settled.beforeResolve?.(responseData);
         if (settled.command === "prompt") {
           if (this.acceptedPromptIds.size >= MAX_PENDING_REQUESTS) {
             const oldest = this.acceptedPromptIds.values().next().value;
@@ -2139,7 +2511,7 @@ class OmpRpcProcess {
           }
           this.acceptedPromptIds.add(response.data.id);
         }
-        settled.resolve(response.data.data);
+        settled.resolve(responseData);
       } catch {
         settled.reject(new Error("OMP RPC response is invalid"));
       }
@@ -2148,6 +2520,22 @@ class OmpRpcProcess {
     }
   }
 
+  private emitAcceptedPromptFailure(id: string, frame: Record<string, unknown>): boolean {
+    if (frame.success !== false || !this.acceptedPromptIds.delete(id)) return false;
+    const error = typeof frame.error === "string" ? frame.error : undefined;
+    const nativeError =
+      error && utf8Bytes(error) <= MAX_RPC_ERROR_BYTES ? error : PROMPT_SCHEDULING_FAILURE;
+    const code = typeof frame.code === "string" ? frame.code : undefined;
+    const nativeCode = code && utf8Bytes(code) <= MAX_RPC_ERROR_CODE_BYTES ? code : undefined;
+    this.emit({
+      type: "prompt_error",
+      id,
+      error: nativeError,
+      ...(nativeCode ? { code: nativeCode } : {}),
+    });
+    return true;
+  }
+
   private takePending(id: string): PendingRequest | undefined {
     const pending = this.pending.get(id);
     if (!pending) return undefined;
@@ -2172,21 +2560,27 @@ class OmpRpcProcess {
       this.fail(new Error("OMP emitted invalid terminal metadata"));
       return true;
     }
+    const structuralFrame = mapRuntimeFrameDetails(frame, omitOptionalDetails);
     const messagesAreSafe =
       frame.messages === undefined ||
       (Array.isArray(frame.messages) &&
         frame.messages.length <= MAX_ARRAY_ITEMS &&
         boundedJsonBytes(
-          frame.messages,
+          structuralFrame.messages as unknown[],
           MAX_SEMANTIC_FRAME_BYTES,
-          MAX_ARRAY_ITEMS,
-          MAX_TEXT_LENGTH,
+          OMP_MAX_CONTENT_PARTS,
+          MAX_IMAGE_DATA_LENGTH,
           4_096,
         ) !== Number.POSITIVE_INFINITY);
     const payloadIsSafe =
       messagesAreSafe &&
-      boundedJsonBytes(frame, MAX_SEMANTIC_FRAME_BYTES, 1_024, MAX_IMAGE_DATA_LENGTH, 4_096) !==
-        Number.POSITIVE_INFINITY;
+      boundedJsonBytes(
+        structuralFrame,
+        MAX_SEMANTIC_FRAME_BYTES,
+        OMP_MAX_CONTENT_PARTS,
+        MAX_IMAGE_DATA_LENGTH,
+        4_096,
+      ) !== Number.POSITIVE_INFINITY;
     if (onlyUnsafePayload && payloadIsSafe) return false;
     if (envelope.data.isTerminal === false) {
       this.fail(new Error("OMP emitted an invalid nonterminal agent_end payload"));
@@ -2213,16 +2607,22 @@ class OmpRpcProcess {
       this.recordProtocolViolation();
       return;
     }
-    if (this.receiveDegradedAgentEnd(frame, true)) return;
+    const safeFrame = mapRuntimeFrameDetails(frame, createOptionalMetadataSanitizer());
+    if (this.receiveDegradedAgentEnd(safeFrame, true)) return;
     if (
-      boundedJsonBytes(frame, MAX_SEMANTIC_FRAME_BYTES, 1_024, MAX_IMAGE_DATA_LENGTH, 4_096) ===
-      Number.POSITIVE_INFINITY
+      boundedJsonBytes(
+        mapRuntimeFrameDetails(safeFrame, omitOptionalDetails),
+        MAX_SEMANTIC_FRAME_BYTES,
+        runtimeFrameCollectionLimit(safeFrame),
+        MAX_IMAGE_DATA_LENGTH,
+        4_096,
+      ) === Number.POSITIVE_INFINITY
     ) {
       this.recordProtocolViolation();
       return;
     }
     if (type === "rpc_chunk") {
-      const chunk = OmpChunkFrameSchema.safeParse(frame);
+      const chunk = OmpChunkFrameSchema.safeParse(safeFrame);
       if (!chunk.success) this.rejectChunk();
       else this.receiveChunk(chunk.data);
       return;
@@ -2240,7 +2640,7 @@ class OmpRpcProcess {
         this.recordProtocolViolation();
         return;
       }
-      const ready = OmpReadyFrameSchema.safeParse(frame);
+      const ready = OmpReadyFrameSchema.safeParse(safeFrame);
       if (!ready.success) {
         this.recordProtocolViolation();
       } else {
@@ -2250,13 +2650,13 @@ class OmpRpcProcess {
       return;
     }
     if (type === "response") {
-      this.receiveResponse(frame);
+      this.receiveResponse(safeFrame);
       return;
     }
-    const event = OmpRuntimeEventSchema.safeParse(frame);
+    const event = OmpRuntimeEventSchema.safeParse(safeFrame);
     if (!event.success) {
-      this.rejectMatchingToolApproval(frame);
-      if (type === "agent_end" && this.receiveDegradedAgentEnd(frame, false)) return;
+      this.rejectMatchingToolApproval(safeFrame);
+      if (type === "agent_end" && this.receiveDegradedAgentEnd(safeFrame, false)) return;
       this.recordProtocolViolation();
       return;
     }
@@ -2595,6 +2995,7 @@ class OmpRpcSession implements OmpRuntimeSession {
     message: string,
     images: readonly OmpImage[] = [],
     onAccepted?: () => void,
+    onRequested?: (requestId: string) => void,
   ): Promise<{ requestId: string; agentInvoked?: boolean }> {
     const safeMessage = validateBoundedText(message, "prompt", MAX_TEXT_LENGTH);
     let acknowledgement: z.infer<typeof OmpPromptAckSchema> | undefined;
@@ -2606,6 +3007,7 @@ class OmpRpcSession implements OmpRuntimeSession {
         onAccepted?.();
       },
     );
+    onRequested?.(request.id);
     await request.promise;
     return { requestId: request.id, ...acknowledgement };
   }
@@ -2664,6 +3066,27 @@ export class OmpRpcRuntime implements OmpRuntime {
         listOmpSessionDescriptors(options, this.options.environment ?? process.env),
     );
   }
+  async readPersistedSessionTranscript(options: {
+    sessionFile: string;
+    sessionId: string;
+    cwd: string;
+    signal?: AbortSignal;
+  }): Promise<OmpPersistedSessionMessages> {
+    const transcript = await readOmpPersistedSessionTranscript(
+      options.sessionFile,
+      options.sessionId,
+      options.cwd,
+      options.signal,
+      join(ompDataDir(this.options.environment ?? process.env), "blobs"),
+    );
+    return {
+      ...transcript,
+      messages: z
+        .array(OmpMessageSchema)
+        .max(100_000)
+        .parse(sanitizeMessageListMetadata(transcript.messages)),
+    };
+  }
   async readPersistedSubagentTranscript(options: {
     parentSessionFile: string;
     childTranscriptId: string;
@@ -2678,7 +3101,10 @@ export class OmpRpcRuntime implements OmpRuntime {
     );
     return {
       ...transcript,
-      messages: z.array(OmpMessageSchema).max(100_000).parse(transcript.messages),
+      messages: z
+        .array(OmpMessageSchema)
+        .max(100_000)
+        .parse(sanitizeMessageListMetadata(transcript.messages)),
     };
   }