@omercnet/paseo-omp 0.4.0-next.129.1 → 0.4.0-next.131.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-omp",
-  "version": "0.4.0-next.129.1",
+  "version": "0.4.0-next.131.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.129.1"; // x-release-please-version
+export const PASEO_OMP_PACKAGE_VERSION = "0.4.0-next.131.1"; // x-release-please-version

package/server/provider/omp-rpc-transport.ts

@@ -159,6 +159,7 @@ export class OmpRpcProcess {
   private readonly terminateProcessTree: (pid: number) => Promise<ProcessTreeCleanup>;
   private readonly streamedBlocks = new Map<number, string>();
   private readonly activeToolCallIds = new Set<string>();
+  private readonly announcedToolCallIds = new Set<string>();
   private pendingWriteBytes = 0;
   private commandTextLength = 0;
   private lineParts: Buffer[] = [];
@@ -1112,6 +1113,7 @@ export class OmpRpcProcess {
     if (event.data.type === "turn_end") {
       this.commandTextLength = 0;
       this.activeToolCallIds.clear();
+      this.announcedToolCallIds.clear();
     }
   }
 
@@ -1133,6 +1135,7 @@ export class OmpRpcProcess {
       this.streamedBlocks.clear();
       this.commandTextLength = 0;
       this.activeToolCallIds.clear();
+      this.announcedToolCallIds.clear();
       return true;
     }
     if (event.type === "command_output") {
@@ -1151,12 +1154,19 @@ export class OmpRpcProcess {
       this.activeToolCallIds.add(event.toolCallId);
       return true;
     }
-    if (event.type === "tool_execution_update" || event.type === "tool_stream_update") {
+    if (event.type === "tool_stream_update") {
+      return (
+        this.activeToolCallIds.has(event.toolCallId) ||
+        this.announcedToolCallIds.has(event.toolCallId)
+      );
+    }
+    if (event.type === "tool_execution_update") {
       return this.activeToolCallIds.has(event.toolCallId);
     }
     if (event.type === "tool_execution_end") {
       if (!this.activeToolCallIds.has(event.toolCallId)) return false;
       this.activeToolCallIds.delete(event.toolCallId);
+      this.announcedToolCallIds.delete(event.toolCallId);
       return true;
     }
     if (
@@ -1174,6 +1184,14 @@ export class OmpRpcProcess {
       nextBlocks.set(0, content);
     } else if (Array.isArray(content)) {
       for (const [index, part] of content.entries()) {
+        if (
+          part.type === "toolCall" &&
+          typeof part.id === "string" &&
+          (this.announcedToolCallIds.has(part.id) ||
+            this.announcedToolCallIds.size < MAX_ACTIVE_TOOLS)
+        ) {
+          this.announcedToolCallIds.add(part.id);
+        }
         const text =
           part.type === "text" ? part.text : part.type === "thinking" ? part.thinking : undefined;
         if (text !== undefined) nextBlocks.set(index, text);

package/server/provider/omp-rpc.ts

@@ -63,6 +63,7 @@ import {
   OmpThinkingLevelSchema,
   validateBoundedText,
 } from "./omp-rpc-values";
+import { buildOmpPromptRequest } from "./prompt-payload";
 import { OmpCleanupFailure, OmpPublicError } from "./security";
 import {
   listOmpSessionDescriptors,
@@ -497,7 +498,7 @@ class OmpRpcSession implements OmpRuntimeSession {
     const safeMessage = validateBoundedText(message, "prompt", MAX_TEXT_LENGTH);
     let acknowledgement: z.infer<typeof OmpPromptAckSchema> | undefined;
     const request = this.process.startRequest(
-      { type: "prompt", message: safeMessage, ...(images.length > 0 ? { images } : {}) },
+      buildOmpPromptRequest(safeMessage, images),
       undefined,
       (value) => {
         acknowledgement = OmpPromptAckSchema.parse(value) ?? {};
@@ -511,7 +512,7 @@ class OmpRpcSession implements OmpRuntimeSession {
 
   async steer(message: string, images: readonly OmpImage[] = []): Promise<void> {
     const safeMessage = validateBoundedText(message, "steer", MAX_TEXT_LENGTH);
-    await this.process.sendFrame({
+    await this.process.request({
       type: "steer",
       message: safeMessage,
       ...(images.length > 0 ? { images } : {}),
@@ -519,7 +520,7 @@ class OmpRpcSession implements OmpRuntimeSession {
   }
   async followUp(message: string, images: readonly OmpImage[] = []): Promise<void> {
     const safeMessage = validateBoundedText(message, "follow-up", MAX_TEXT_LENGTH);
-    await this.process.sendFrame({
+    await this.process.request({
       type: "follow_up",
       message: safeMessage,
       ...(images.length > 0 ? { images } : {}),

package/server/provider/prompt-payload.ts

@@ -14,6 +14,14 @@ export function isSafeCommandName(name: string): boolean {
 }
 
 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;
 
@@ -222,12 +230,10 @@ export function inlinePromptFrameBytes(
   delivery: "prompt" | "steer",
 ): number {
   const images = payload.images.map(({ type, mimeType }) => ({ type, data: "", mimeType }));
-  const frame = {
-    type: delivery,
-    message: payload.text,
-    ...(images.length > 0 ? { images } : {}),
-    ...(delivery === "prompt" ? { id: "" } : {}),
-  };
+  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)) +

package/server/provider/timeline-projector.ts

@@ -80,6 +80,10 @@ type ToolSnapshot = {
   specializedRendered: boolean;
   silent: boolean;
 };
+type PendingToolStream = {
+  output: JsonValue;
+  retainedBytes: number;
+};
 
 export interface OmpTimelineScheduler {
   set(callback: () => void | Promise<void>, delayMs: number): unknown;
@@ -354,6 +358,8 @@ type CompactionSlot = {
 
 export class OmpTimelineProjector {
   private readonly tools = new Map<string, ToolSnapshot>();
+  private readonly pendingToolStreams = new Map<string, PendingToolStream>();
+  private pendingToolStreamBytes = 0;
   private stream: StreamSnapshot | null = null;
   private flushTimer: unknown;
   private currentTurnId: string | null = null;
@@ -493,6 +499,11 @@ export class OmpTimelineProjector {
         return;
       case "tool_execution_start": {
         this.flush(true);
+        const pendingStream = this.pendingToolStreams.get(event.toolCallId);
+        if (pendingStream) {
+          this.pendingToolStreams.delete(event.toolCallId);
+          this.pendingToolStreamBytes -= pendingStream.retainedBytes;
+        }
         if (this.toolIdentitySaturated || this.retiredToolCallIds.has(event.toolCallId)) return;
         const previous = this.tools.get(event.toolCallId);
         if (!previous && this.tools.size >= MAX_ACTIVE_TOOLS) return;
@@ -501,7 +512,17 @@ export class OmpTimelineProjector {
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
         );
-        const retainedBytes = boundedJsonBytes(input, MAX_PUBLIC_TOOL_PAYLOAD_BYTES);
+        const inputBytes = boundedJsonBytes(input, MAX_PUBLIC_TOOL_PAYLOAD_BYTES);
+        let output = pendingStream?.output ?? null;
+        let retainedBytes = inputBytes + (pendingStream?.retainedBytes ?? 0);
+        if (
+          pendingStream &&
+          this.activeToolBytes - (previous?.retainedBytes ?? 0) + retainedBytes >
+            MAX_ACTIVE_TOOL_BYTES
+        ) {
+          output = null;
+          retainedBytes = inputBytes;
+        }
         if (
           this.activeToolBytes - (previous?.retainedBytes ?? 0) + retainedBytes >
           MAX_ACTIVE_TOOL_BYTES
@@ -520,7 +541,7 @@ export class OmpTimelineProjector {
           nativeName: event.toolName,
           name: this.dataFilter.text(displayName, 256),
           input,
-          output: null,
+          output,
           retainedBytes,
           turnId,
           generation: this.runtimeGeneration,
@@ -534,15 +555,28 @@ export class OmpTimelineProjector {
       }
       case "tool_execution_update":
       case "tool_stream_update": {
-        const previous = this.tools.get(event.toolCallId);
-        if (!previous) return;
-        if (previous.turnId !== turnId || previous.generation !== this.runtimeGeneration) return;
         const output = this.dataFilter.json(
           event.type === "tool_execution_update" ? event.partialResult : event.update,
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
           MAX_PUBLIC_TOOL_PAYLOAD_BYTES,
         );
         const outputBytes = boundedJsonBytes(output, MAX_PUBLIC_TOOL_PAYLOAD_BYTES);
+        const previous = this.tools.get(event.toolCallId);
+        if (!previous) {
+          if (event.type !== "tool_stream_update") return;
+          const pending = this.pendingToolStreams.get(event.toolCallId);
+          if (!pending && this.pendingToolStreams.size >= MAX_ACTIVE_TOOLS) return;
+          if (
+            this.pendingToolStreamBytes - (pending?.retainedBytes ?? 0) + outputBytes >
+            MAX_ACTIVE_TOOL_BYTES
+          ) {
+            return;
+          }
+          this.pendingToolStreamBytes += outputBytes - (pending?.retainedBytes ?? 0);
+          this.pendingToolStreams.set(event.toolCallId, { output, retainedBytes: outputBytes });
+          return;
+        }
+        if (previous.turnId !== turnId || previous.generation !== this.runtimeGeneration) return;
         const inputBytes = boundedJsonBytes(previous.input, MAX_PUBLIC_TOOL_PAYLOAD_BYTES);
         const retainedBytes = inputBytes + outputBytes;
         if (this.activeToolBytes - previous.retainedBytes + retainedBytes > MAX_ACTIVE_TOOL_BYTES)
@@ -869,6 +903,7 @@ export class OmpTimelineProjector {
     this.activeToolBytes = 0;
     this.replayToolCalls.clear();
     this.tools.clear();
+    this.clearPendingToolStreams();
     this.commandText = "";
     this.commandPublishedText = "";
     this.revertEntryByToken.clear();
@@ -1136,6 +1171,7 @@ export class OmpTimelineProjector {
     this.clearFlushTimer();
     this.stream = null;
     this.tools.clear();
+    this.clearPendingToolStreams();
     this.replayToolCalls.clear();
     this.activeToolBytes = 0;
     this.replayCandidates.clear();
@@ -1176,6 +1212,11 @@ export class OmpTimelineProjector {
     }
     this.activeToolBytes = 0;
     this.tools.clear();
+    this.clearPendingToolStreams();
+  }
+  private clearPendingToolStreams(): void {
+    this.pendingToolStreams.clear();
+    this.pendingToolStreamBytes = 0;
   }
   private ensureTurn(turnId: string): void {
     if (this.currentTurnId === turnId) return;