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

package/server/provider/subsessions.ts

@@ -94,6 +94,18 @@ const TaskResultDetailsSchema = z.object({
         exitCode: z.number().optional(),
         error: z.unknown().optional(),
         aborted: z.boolean().optional(),
+        status: z
+          .enum([
+            "pending",
+            "running",
+            "completed",
+            "failed",
+            "error",
+            "aborted",
+            "canceled",
+            "cancelled",
+          ])
+          .optional(),
       }),
     )
     .max(MAX_CHILDREN),
@@ -192,8 +204,15 @@ function replayChildren(messages: readonly OmpMessage[]): ReplayChildRef[] {
     const details = taskResultDetails(message);
     const results = details?.results ?? [];
     for (const result of results) {
+      const canceled =
+        result.aborted === true ||
+        result.status === "aborted" ||
+        result.status === "canceled" ||
+        result.status === "cancelled";
       const failed =
         message.isError === true ||
+        result.status === "failed" ||
+        result.status === "error" ||
         Boolean(result.error) ||
         (typeof result.exitCode === "number" && result.exitCode !== 0);
       children.push({
@@ -201,7 +220,7 @@ function replayChildren(messages: readonly OmpMessage[]): ReplayChildRef[] {
         agent: result.agent ?? call?.title,
         description: call?.description,
         parentToolCallId: message.toolCallId,
-        status: result.aborted === true ? "canceled" : failed ? "failed" : "completed",
+        status: canceled ? "canceled" : failed ? "failed" : "completed",
       });
     }
     const resultIds = new Set(results.map((result) => result.id));
@@ -304,6 +323,7 @@ export class OmpSubsessionProjector {
     private readonly scheduler: OmpTimelineScheduler,
     private readonly onActivityChange: () => void,
     private readonly outputRedactionValues: readonly string[],
+    private readonly pluginTimelineEnabled = false,
   ) {
     this.dataFilter = new OmpPublicDataSerializer(outputRedactionValues);
   }
@@ -540,6 +560,8 @@ export class OmpSubsessionProjector {
         this.emit,
         this.scheduler,
         this.outputRedactionValues,
+        false,
+        this.pluginTimelineEnabled,
       ),
     };
     this.children.set(sessionId, child);
@@ -552,7 +574,8 @@ export class OmpSubsessionProjector {
       type: "session.opened",
       sessionId,
       parentSessionId,
-      capabilities: [],
+      toolCallId: ref.parentToolCallId,
+      capabilities: ["session.subsession"],
       restoration: "parent",
       cwd: this.cwd,
       title,

package/server/provider/timeline-projector.ts

@@ -4,19 +4,22 @@ import type {
   ProviderTimelineItem,
   ProviderToolCallDetail,
 } from "@getpaseo/plugin/server/provider";
+import { OMP_MCP_AUTH_TIMELINE_KIND } from "../../shared/mcp";
 import { isOmpImageMimeType, isValidImagePayload, type OmpImageMimeType } from "./image";
-import type { OmpMessage, OmpRpcEvent } from "./omp-rpc";
+import { OMP_MAX_CONTENT_PARTS, type OmpMessage, type OmpRpcEvent } from "./omp-rpc";
 import {
   boundedJsonBytes,
   type JsonValue,
   OmpPublicDataSerializer,
   OmpPublicError,
+  truncateUtf8,
   utf8Bytes,
 } from "./security";
 
 const STREAM_FRAME_MS = 32;
-const MAX_STREAM_CONTENT_BLOCKS = 64;
 const MAX_STREAM_TEXT_LENGTH = 4 * 1024 * 1024;
+const MAX_RAW_STREAM_TEXT_LENGTH = 8 * 1024 * 1024;
+const MAX_REDACTED_STREAM_TEXT_LENGTH = MAX_RAW_STREAM_TEXT_LENGTH * 3;
 const MAX_ACTIVE_TOOLS = 64;
 const MAX_TODOS = 256;
 const MAX_TURN_NATIVE_IDENTITIES = 1_024;
@@ -54,6 +57,7 @@ type StreamSnapshot = {
   nativeIdentity?: string;
   published: boolean;
   retainedBytes: number;
+  textBytes: number;
   publishedBytes: number;
   blocks: Map<number, StreamBlockSnapshot>;
   dirtyBlocks: Set<number>;
@@ -196,6 +200,17 @@ function publishableHttpUrl(value: string | undefined): string | undefined {
     return undefined;
   }
 }
+function isOmpOAuthLaunchUrl(value: string | undefined): boolean {
+  const url = publishableHttpUrl(value);
+  if (!url) return false;
+  const parsed = new URL(url);
+  return (
+    (parsed.hostname === "localhost" ||
+      parsed.hostname === "127.0.0.1" ||
+      parsed.hostname === "[::1]") &&
+    parsed.pathname === "/launch"
+  );
+}
 
 function todoPublicId(nativeId: string | undefined, index: number): string {
   if (!nativeId) return `omp:todo:${index}`;
@@ -240,7 +255,7 @@ function nativeImageResult(
     boundedJsonBytes(
       value,
       MAX_NATIVE_IMAGE_RESULT_BYTES,
-      MAX_STREAM_CONTENT_BLOCKS,
+      OMP_MAX_CONTENT_PARTS,
       8 * 1024 * 1024,
       512,
     ) === Number.POSITIVE_INFINITY
@@ -350,6 +365,7 @@ export class OmpTimelineProjector {
   private readonly replayCandidates = new Map<string, ReplayCandidate>();
   private readonly replayOverflowCandidates = new Map<string, string>();
   private projectingReplay = false;
+  private readonly replayToolCalls = new Map<string, { toolName: string; args: unknown }>();
   private customSequence = 0;
   private compactionSequence = 0;
   private activeCompaction: CompactionSlot | null = null;
@@ -366,6 +382,7 @@ export class OmpTimelineProjector {
   private closed = false;
 
   private readonly dataFilter: OmpPublicDataSerializer;
+  private browserAuthorizationIssuer: ((url: string) => string | undefined) | null = null;
 
   constructor(
     private readonly sessionId: string,
@@ -373,10 +390,14 @@ export class OmpTimelineProjector {
     private readonly scheduler: OmpTimelineScheduler = defaultOmpTimelineScheduler,
     outputRedactionValues: readonly string[] = [],
     private readonly conversationRevertEnabled = false,
+    private readonly pluginTimelineEnabled = false,
     private readonly hostToolLabels: ReadonlyMap<string, string> = new Map(),
   ) {
     this.dataFilter = new OmpPublicDataSerializer(outputRedactionValues);
   }
+  setBrowserAuthorizationIssuer(issue: ((url: string) => string | undefined) | null): void {
+    this.browserAuthorizationIssuer = issue;
+  }
 
   project(event: OmpRpcEvent, turnId: string, bypassReplayFilter = false): void {
     if (this.closed) return;
@@ -601,15 +622,40 @@ export class OmpTimelineProjector {
       return;
     }
     if (event.type === "extension_ui_request" && event.method === "open_url") {
-      const url = publishableHttpUrl(event.launchUrl ?? event.url);
+      const url = publishableHttpUrl(event.url);
       if (!url) return;
       this.noticeSequence += 1;
-      const message = [event.instructions, url].filter(Boolean).join("\n");
+      const instructions = event.instructions
+        ? this.dataFilter.text(event.instructions, 64 * 1024)
+        : undefined;
+      const publicUrl = this.dataFilter.text(url, 16_384);
+      const isMcpAuthorization = isOmpOAuthLaunchUrl(event.launchUrl);
+      if (this.pluginTimelineEnabled && isMcpAuthorization && publishableHttpUrl(publicUrl)) {
+        const browserAuthorizationToken = this.browserAuthorizationIssuer?.(publicUrl);
+        this.publish({
+          type: "plugin",
+          id: `omp:ui:${this.noticeSequence}`,
+          pluginId: "paseo-omp",
+          kind: OMP_MCP_AUTH_TIMELINE_KIND,
+          version: 1,
+          data: {
+            url: publicUrl,
+            ...(instructions ? { instructions } : {}),
+            loopbackCallback: true,
+            ...(browserAuthorizationToken ? { browserAuthorizationToken } : {}),
+          },
+        });
+        return;
+      }
+      const remoteHint = isMcpAuthorization
+        ? "Remote client: if the localhost callback cannot connect, paste the final redirect URL or authorization code into the OMP prompt in this chat."
+        : undefined;
+      const message = [instructions, publicUrl, remoteHint].filter(Boolean).join("\n");
       this.publish({
         type: "notification",
         id: `omp:ui:${this.noticeSequence}`,
         level: "info",
-        message: this.dataFilter.text(message, 64 * 1024),
+        message,
       });
       return;
     }
@@ -783,6 +829,7 @@ export class OmpTimelineProjector {
     this.replayOverflowCandidates.clear();
     this.projectingReplay = false;
     this.activeToolBytes = 0;
+    this.replayToolCalls.clear();
     this.tools.clear();
     this.commandText = "";
     this.commandPublishedText = "";
@@ -795,6 +842,7 @@ export class OmpTimelineProjector {
     const nativeIdentity = assistantIdentity(message);
     this.replaySequence += 1;
     if (message.role === "user") {
+      this.replayToolCalls.clear();
       if (this.replayTurnId) this.finishTurn(this.replayTurnId);
       this.replayTurnId = `omp:replay-turn:${this.replaySequence}`;
       const text =
@@ -823,15 +871,7 @@ export class OmpTimelineProjector {
           for (const part of message.content) {
             if (part.type !== "toolCall" || !part.id || !part.name || part.arguments === undefined)
               continue;
-            this.project(
-              {
-                type: "tool_execution_start",
-                toolCallId: part.id,
-                toolName: part.name,
-                args: part.arguments,
-              },
-              this.replayTurnId,
-            );
+            this.replayToolCalls.set(part.id, { toolName: part.name, args: part.arguments });
           }
         }
       } finally {
@@ -842,13 +882,15 @@ export class OmpTimelineProjector {
     }
     this.replayTurnId ??= `omp:replay-turn:${this.replaySequence}`;
     if (message.role === "toolResult") {
+      const replayCall = this.replayToolCalls.get(message.toolCallId);
+      this.replayToolCalls.delete(message.toolCallId);
       if (!this.tools.has(message.toolCallId)) {
         this.project(
           {
             type: "tool_execution_start",
             toolCallId: message.toolCallId,
-            toolName: message.toolName,
-            args: null,
+            toolName: replayCall?.toolName ?? message.toolName,
+            args: replayCall?.args ?? null,
           },
           this.replayTurnId,
         );
@@ -869,10 +911,7 @@ export class OmpTimelineProjector {
       return;
     }
     if (message.role === "bashExecution") {
-      const text = message.output
-        ? `$ ${message.command}\n${message.output}`
-        : `$ ${message.command}`;
-      this.project({ type: "command_output", text }, this.replayTurnId);
+      this.publishCustomMessage(message);
       this.finishTurn(this.replayTurnId);
       this.replayTurnId = null;
     }
@@ -880,6 +919,7 @@ export class OmpTimelineProjector {
 
   finishReplay(): void {
     if (this.replayTurnId) this.finishTurn(this.replayTurnId);
+    this.replayToolCalls.clear();
     this.replayTurnId = null;
   }
   acceptLiveTurn(turnId: string): void {
@@ -967,13 +1007,28 @@ export class OmpTimelineProjector {
     if (!this.stream || this.closed || this.stream.dirtyBlocks.size === 0) return;
     const stream = this.stream;
     if (!stream.nativeIdentity && !finalizeFallback) return;
-    const indexes = [...stream.dirtyBlocks].sort((left, right) => left - right);
+    const indexes = [...stream.blocks.keys()].sort((left, right) => left - right);
+    let remainingTextBytes = MAX_STREAM_TEXT_LENGTH;
     stream.dirtyBlocks.clear();
     for (const contentIndex of indexes) {
       const block = stream.blocks.get(contentIndex);
-      if (!block?.text) continue;
-      const publicText = block.kind === "image" ? block.text : this.dataFilter.text(block.text);
-      if (!publicText || block.publishedText === publicText) continue;
+      if (!block) continue;
+      const publicText =
+        block.kind === "image"
+          ? block.text
+          : truncateUtf8(
+              this.dataFilter.text(block.text, MAX_REDACTED_STREAM_TEXT_LENGTH),
+              remainingTextBytes,
+            );
+      if (block.kind !== "image") {
+        remainingTextBytes = Math.max(0, remainingTextBytes - utf8Bytes(publicText));
+      }
+      if (
+        block.publishedText === publicText ||
+        (!publicText && block.publishedText === undefined)
+      ) {
+        continue;
+      }
       const nextPublishedBytes = utf8Bytes(publicText);
       if (
         stream.retainedBytes + stream.publishedBytes + nextPublishedBytes >
@@ -1027,9 +1082,11 @@ export class OmpTimelineProjector {
     if (this.currentTurnId) this.publishCommand(this.currentTurnId);
     this.retireCompactions("OMP compaction ended when the session closed");
     this.closed = true;
+    this.browserAuthorizationIssuer = null;
     this.clearFlushTimer();
     this.stream = null;
     this.tools.clear();
+    this.replayToolCalls.clear();
     this.activeToolBytes = 0;
     this.replayCandidates.clear();
     this.replayOverflowCandidates.clear();
@@ -1091,6 +1148,7 @@ export class OmpTimelineProjector {
       ...(nativeIdentity ? { nativeIdentity } : {}),
       published: false,
       retainedBytes: 0,
+      textBytes: 0,
       publishedBytes: 0,
       blocks: new Map(),
       dirtyBlocks: new Set(),
@@ -1155,7 +1213,7 @@ export class OmpTimelineProjector {
       return;
     }
     if (!Array.isArray(message.content)) return;
-    const blockCount = Math.min(message.content.length, MAX_STREAM_CONTENT_BLOCKS);
+    const blockCount = Math.min(message.content.length, OMP_MAX_CONTENT_PARTS);
     for (let index = 0; index < blockCount; index += 1) {
       const block = blockText(message, index);
       if (block) this.setBlock(stream, index, block);
@@ -1215,28 +1273,22 @@ export class OmpTimelineProjector {
     if (snapshot.kind === "image" && utf8Bytes(snapshot.text) > MAX_IMAGE_ENCODED_LENGTH + 256)
       return;
     const previous = stream.blocks.get(contentIndex);
-    let retainedBytes = utf8Bytes(snapshot.text);
-    let textBytes = snapshot.kind === "image" ? 0 : retainedBytes;
-    for (const [index, block] of stream.blocks) {
-      if (index === contentIndex) continue;
-      const blockBytes = utf8Bytes(block.text);
-      retainedBytes += blockBytes;
-      if (block.kind !== "image") textBytes += blockBytes;
-      if (
-        retainedBytes + stream.publishedBytes > MAX_STREAM_TOTAL_BYTES ||
-        textBytes > MAX_STREAM_TEXT_LENGTH
-      ) {
-        return;
-      }
-    }
+    const previousBytes = previous ? utf8Bytes(previous.text) : 0;
+    const snapshotBytes = utf8Bytes(snapshot.text);
+    const retainedBytes = stream.retainedBytes - previousBytes + snapshotBytes;
+    const textBytes =
+      stream.textBytes -
+      (previous && previous.kind !== "image" ? previousBytes : 0) +
+      (snapshot.kind === "image" ? 0 : snapshotBytes);
     if (
       retainedBytes + stream.publishedBytes > MAX_STREAM_TOTAL_BYTES ||
-      textBytes > MAX_STREAM_TEXT_LENGTH
+      textBytes > MAX_RAW_STREAM_TEXT_LENGTH
     ) {
       return;
     }
     if (previous?.kind === snapshot.kind && previous.text === snapshot.text) return;
     stream.retainedBytes = retainedBytes;
+    stream.textBytes = textBytes;
     stream.blocks.set(contentIndex, {
       ...snapshot,
       ...(previous?.kind === snapshot.kind ? { publishedText: previous.publishedText } : {}),
@@ -1248,13 +1300,13 @@ export class OmpTimelineProjector {
     return (
       Number.isSafeInteger(contentIndex) &&
       contentIndex >= 0 &&
-      contentIndex < MAX_STREAM_CONTENT_BLOCKS
+      contentIndex < OMP_MAX_CONTENT_PARTS
     );
   }
 
   private publishCommand(turnId: string): void {
     if (!this.commandText) return;
-    const publicText = this.dataFilter.text(this.commandText);
+    const publicText = this.dataFilter.text(this.commandText, MAX_STREAM_TEXT_LENGTH);
     if (!publicText || publicText === this.commandPublishedText) return;
     this.commandPublishedText = publicText;
     this.publish({
@@ -1340,13 +1392,21 @@ export class OmpTimelineProjector {
           type: "shell",
           command,
           ...(firstString(details, "cwd") ? { cwd: firstString(details, "cwd") } : {}),
-          ...(output ? { output: this.dataFilter.text(output) } : {}),
+          ...(output ? { output: this.dataFilter.text(output, MAX_STREAM_TEXT_LENGTH) } : {}),
           ...(typeof message.exitCode === "number" || message.exitCode === null
             ? { exitCode: message.exitCode }
             : typeof details?.exitCode === "number"
               ? { exitCode: details.exitCode }
               : {}),
         },
+        ...(message.cancelled !== undefined || message.truncated !== undefined
+          ? {
+              metadata: {
+                ...(message.cancelled !== undefined ? { cancelled: message.cancelled } : {}),
+                ...(message.truncated !== undefined ? { truncated: message.truncated } : {}),
+              },
+            }
+          : {}),
         status: message.cancelled ? "canceled" : "completed",
         error: null,
       });