@omercnet/paseo-omp 5.1.1 → 5.2.0-next.362.1

package/server/provider/subsessions.ts

@@ -2,6 +2,12 @@ import { createHash } from "node:crypto";
 import { basename, extname, isAbsolute } from "node:path";
 import type { ProviderEvent } from "@getpaseo/plugin/server/provider";
 import { z } from "zod";
+import {
+  MAX_OMP_SUBAGENT_STRIP_ENTRIES,
+  OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH,
+  OMP_SUBAGENT_STRIP_KIND,
+  type OmpSubagentStrip,
+} from "../../shared/subagents";
 import type { OmpRuntime, OmpRuntimeSession } from "./omp-rpc";
 import type {
   OmpAgentSessionEvent,
@@ -56,6 +62,7 @@ type ChildState = {
   sessionClosed: boolean;
   replayUnavailable?: boolean;
   seenInSnapshot: boolean;
+  runningSince: number;
   seenAssistantIdentities: BoundedStringSet;
   projector: OmpTimelineProjector;
 };
@@ -305,6 +312,19 @@ function terminalStatus(status: string): ChildTerminalStatus | undefined {
   return;
 }
 
+/**
+ * OMP derives subagent IDs from model-chosen task names, so clients only see this opaque handle,
+ * scoped to the provider session that owns the subagent.
+ */
+export function ompSubagentHandle(sessionId: string, nativeId: string): string {
+  return createHash("sha256")
+    .update(sessionId)
+    .update("\0")
+    .update(nativeId)
+    .digest("base64url")
+    .slice(0, 32);
+}
+
 function bufferedNativeId(event: OmpSubagentEvent): string {
   return event.type === "subagent_progress" ? event.payload.progress.id : event.payload.id;
 }
@@ -314,6 +334,10 @@ export class OmpSubsessionProjector {
   private readonly sessionIdByNativeId = new Map<string, string>();
   private readonly toolOwners = new Map<string, string>();
   private readonly dispatches = new Map<string, TaskDispatch>();
+  /** Last published payload of each non-empty subagent control strip, by timeline item ID. */
+  private readonly controlStrips = new Map<string, string>();
+  /** Root `task` calls whose tool card the root timeline has published, oldest first. */
+  private readonly anchoredRootTasks = new Set<string>();
   private readonly bufferedEvents: BufferedSubagentEvent[] = [];
   // null means every child observed during this replay is omitted after tombstone saturation.
   private omittedBufferedChildren: Set<string> | null = new Set();
@@ -368,7 +392,7 @@ export class OmpSubsessionProjector {
     if (event.isError) {
       this.dispatches.delete(event.toolCallId);
       this.toolOwners.delete(event.toolCallId);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     dispatch.acknowledged = true;
@@ -462,6 +486,82 @@ export class OmpSubsessionProjector {
     this.reconcileSnapshots(await runtime.getSubagents());
   }
 
+  private activityChanged(): void {
+    this.publishControlStrips();
+    this.onActivityChange();
+  }
+
+  /**
+   * Marks a root `task` call whose tool card is now in the root timeline. Its control strip is
+   * published only after this, so the strip lands below the card even when subagent frames
+   * arrive while the turn's own events are still buffered.
+   */
+  anchorRootTask(toolCallId: string): void {
+    if (this.anchoredRootTasks.size >= MAX_TASK_DISPATCHES) {
+      const oldest = this.anchoredRootTasks.values().next().value;
+      if (oldest !== undefined) this.anchoredRootTasks.delete(oldest);
+    }
+    this.anchoredRootTasks.add(toolCallId);
+    this.publishControlStrips();
+  }
+
+  /**
+   * Publishes one plugin timeline row per root `task` call, below its tool card, listing the
+   * call's running subagents so the client can steer or cancel them in place. A row is emptied
+   * rather than removed when its subagents finish.
+   */
+  private publishControlStrips(): void {
+    if (!this.pluginTimelineEnabled || this.closed) return;
+    const strips = new Map<string, OmpSubagentStrip["subagents"]>();
+    for (const child of this.children.values()) {
+      if (child.status !== "running") continue;
+      const taskCallId = this.rootTaskCallId(child);
+      if (!taskCallId || !this.anchoredRootTasks.has(taskCallId)) continue;
+      const id = `omp:subagents:${taskCallId}`;
+      const entries = strips.get(id) ?? [];
+      if (entries.length >= MAX_OMP_SUBAGENT_STRIP_ENTRIES) continue;
+      entries.push({
+        id: ompSubagentHandle(this.rootSessionId, child.nativeId),
+        agent: child.title,
+        description: child.description
+          ? this.dataFilter.text(child.description, OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH)
+          : null,
+        runningSince: child.runningSince,
+      });
+      strips.set(id, entries);
+    }
+    for (const id of new Set([...this.controlStrips.keys(), ...strips.keys()])) {
+      const data: OmpSubagentStrip = { subagents: strips.get(id) ?? [] };
+      const payload = JSON.stringify(data);
+      if (this.controlStrips.get(id) === payload) continue;
+      if (data.subagents.length > 0) this.controlStrips.set(id, payload);
+      else this.controlStrips.delete(id);
+      this.emit({
+        type: "timeline.item",
+        sessionId: this.rootSessionId,
+        item: {
+          type: "plugin",
+          id,
+          pluginId: "paseo-omp",
+          kind: OMP_SUBAGENT_STRIP_KIND,
+          version: 1,
+          data,
+        },
+      });
+    }
+  }
+
+  /** The root timeline's `task` call that a subagent descends from, when it is known. */
+  private rootTaskCallId(child: ChildState): string | undefined {
+    let current = child;
+    for (let depth = 0; current.parentSessionId !== this.rootSessionId; depth += 1) {
+      const parent = this.children.get(current.parentSessionId);
+      if (!parent || depth >= MAX_CHILDREN) return;
+      current = parent;
+    }
+    return current.parentToolCallId;
+  }
+
   hasActiveChildren(): boolean {
     for (const child of this.children.values()) if (child.status === "running") return true;
     for (const dispatch of this.dispatches.values()) if (dispatch.acknowledged) return true;
@@ -474,7 +574,7 @@ export class OmpSubsessionProjector {
     }
     this.dispatches.clear();
     this.toolOwners.clear();
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   close(): void {
@@ -626,7 +726,7 @@ export class OmpSubsessionProjector {
       const terminal = terminalStatus(event.payload.status);
       if (terminal) this.requestTerminal(child, terminal);
       else if (event.payload.status === "started") this.restartChild(child);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     if (event.type === "subagent_progress") {
@@ -643,7 +743,7 @@ export class OmpSubsessionProjector {
       const terminal = terminalStatus(event.payload.progress.status);
       if (terminal) this.requestTerminal(child, terminal);
       else this.restartChild(child);
-      this.onActivityChange();
+      this.activityChanged();
       return;
     }
     const sessionId = this.sessionIdByNativeId.get(event.payload.id);
@@ -701,6 +801,7 @@ export class OmpSubsessionProjector {
       ...(ref.sessionFile ? { sessionFile: ref.sessionFile } : {}),
       ...(ref.parentToolCallId ? { parentToolCallId: ref.parentToolCallId } : {}),
       status: "running",
+      runningSince: Date.now(),
       sessionClosed: false,
       seenAssistantIdentities: new BoundedStringSet(MAX_CHILD_MESSAGE_IDENTITIES),
       seenInSnapshot: false,
@@ -739,6 +840,7 @@ export class OmpSubsessionProjector {
     child.replayUnavailable = false;
     if (child.status === "running") return;
     child.status = "running";
+    child.runningSince = Date.now();
     child.terminalRequested = undefined;
     child.seenInSnapshot = false;
     child.turnSequence += 1;
@@ -784,7 +886,7 @@ export class OmpSubsessionProjector {
     if (parent?.terminalRequested && !this.hasDirectActivity(parent.sessionId)) {
       this.finishChild(parent, parent.terminalRequested);
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
   private failReplayChild(child: ChildState): void {
     child.replayUnavailable = true;
@@ -812,7 +914,7 @@ export class OmpSubsessionProjector {
     if (owner?.terminalRequested && !this.hasDirectActivity(owner.sessionId)) {
       this.finishChild(owner, owner.terminalRequested);
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   private resolveParent(parentToolCallId?: string, sessionFile?: string): string {
@@ -864,7 +966,7 @@ export class OmpSubsessionProjector {
         this.requestTerminal(child, "completed");
       }
     }
-    this.onActivityChange();
+    this.activityChanged();
   }
 
   private async replaySnapshots(

package/server/provider/timeline-projector.ts

@@ -372,8 +372,8 @@ export class OmpTimelineProjector {
   private flushTimer: unknown;
   private currentTurnId: string | null = null;
   private assistantSequence = 0;
+  // Least recently used first, so a long turn evicts its oldest identities.
   private readonly turnNativeMessageIds = new Map<string, string>();
-  private nativeIdentitySaturated = false;
   private assistantIdentitySequence = 0;
   private noticeSequence = 0;
   private toolSequence = 0;
@@ -467,6 +467,9 @@ export class OmpTimelineProjector {
       event.type === "auto_compaction_end" ||
       event.type === "compaction_start" ||
       event.type === "compaction_end" ||
+      event.type === "manual_compaction_start" ||
+      event.type === "manual_compaction_end" ||
+      event.type === "extension_error" ||
       event.type === "advisor_yielded" ||
       event.type === "config_warnings_changed" ||
       event.type === "advisor_cost_changed" ||
@@ -743,6 +746,19 @@ export class OmpTimelineProjector {
       });
       return;
     }
+    if (event.type === "extension_error") {
+      this.noticeSequence += 1;
+      this.publish({
+        type: "notification",
+        id: `omp:extension-error:${this.noticeSequence}`,
+        level: "error",
+        message: this.dataFilter.text(
+          `OMP extension ${event.extensionPath} failed in ${event.event}: ${event.error}`,
+          64 * 1024,
+        ),
+      });
+      return;
+    }
     if (event.type === "advisor_yielded") {
       this.noticeSequence += 1;
       this.publish({
@@ -753,7 +769,11 @@ export class OmpTimelineProjector {
       });
       return;
     }
-    if (event.type === "auto_compaction_start" || event.type === "compaction_start") {
+    if (
+      event.type === "auto_compaction_start" ||
+      event.type === "compaction_start" ||
+      event.type === "manual_compaction_start"
+    ) {
       const trigger = event.type === "auto_compaction_start" ? "auto" : "manual";
       const action = event.type === "auto_compaction_start" ? event.action : undefined;
       if (this.discardedCompactionEnds > 0) {
@@ -781,7 +801,11 @@ export class OmpTimelineProjector {
       this.publish({ type: "compaction", id: slot.id, status: "loading", trigger });
       return;
     }
-    if (event.type === "auto_compaction_end" || event.type === "compaction_end") {
+    if (
+      event.type === "auto_compaction_end" ||
+      event.type === "compaction_end" ||
+      event.type === "manual_compaction_end"
+    ) {
       if (this.discardedCompactionEnds > 0) {
         this.discardedCompactionEnds -= 1;
         return;
@@ -803,7 +827,7 @@ export class OmpTimelineProjector {
         this.discardedCompactionEnds = 1;
         return;
       }
-      if (event.willRetry) {
+      if (event.type !== "manual_compaction_end" && event.willRetry) {
         slot.retrying = true;
         return;
       }
@@ -826,10 +850,9 @@ export class OmpTimelineProjector {
           type: "notification",
           id: `${slot.id}:skipped`,
           level: "warning",
-          message: "OMP compaction was skipped",
+          message: this.dataFilter.text(event.errorMessage ?? "OMP compaction was skipped", 4_096),
         });
-      }
-      if (event.aborted || event.errorMessage) {
+      } else if (event.aborted || event.errorMessage) {
         this.publish({
           type: "error",
           id: `${slot.id}:error`,
@@ -901,7 +924,6 @@ export class OmpTimelineProjector {
     this.currentTurnId = null;
     this.assistantSequence = 0;
     this.turnNativeMessageIds.clear();
-    this.nativeIdentitySaturated = false;
     this.assistantIdentitySequence = 0;
     this.toolSequence = 0;
     this.userSequence = 0;
@@ -1174,7 +1196,6 @@ export class OmpTimelineProjector {
     this.currentTurnId = null;
     this.assistantSequence = 0;
     this.turnNativeMessageIds.clear();
-    this.nativeIdentitySaturated = false;
   }
 
   close(): void {
@@ -1242,13 +1263,12 @@ export class OmpTimelineProjector {
     this.commandPublishedText = "";
   }
 
-  private beginStream(message: OmpAssistantMessage, turnId: string): StreamSnapshot | null {
+  private beginStream(message: OmpAssistantMessage, turnId: string): StreamSnapshot {
     this.assistantSequence += 1;
     const nativeIdentity = assistantIdentity(message);
     const messageId = nativeIdentity
       ? this.messageIdForNativeIdentity(nativeIdentity)
       : this.nextAssistantMessageId(`turn:${turnId}:${this.assistantSequence}`);
-    if (!messageId) return null;
     this.stream = {
       messageId,
       ...(nativeIdentity ? { nativeIdentity } : {}),
@@ -1261,15 +1281,16 @@ export class OmpTimelineProjector {
     };
     return this.stream;
   }
-  private messageIdForNativeIdentity(nativeIdentity: string): string | undefined {
+  private messageIdForNativeIdentity(nativeIdentity: string): string {
     const existing = this.turnNativeMessageIds.get(nativeIdentity);
-    if (existing) return existing;
-    if (
-      this.nativeIdentitySaturated ||
-      this.turnNativeMessageIds.size >= MAX_TURN_NATIVE_IDENTITIES
-    ) {
-      this.nativeIdentitySaturated = true;
-      return undefined;
+    if (existing) {
+      this.turnNativeMessageIds.delete(nativeIdentity);
+      this.turnNativeMessageIds.set(nativeIdentity, existing);
+      return existing;
+    }
+    if (this.turnNativeMessageIds.size >= MAX_TURN_NATIVE_IDENTITIES) {
+      const oldest = this.turnNativeMessageIds.keys().next().value;
+      if (oldest !== undefined) this.turnNativeMessageIds.delete(oldest);
     }
     const messageId = this.nextAssistantMessageId(nativeIdentity);
     this.turnNativeMessageIds.set(nativeIdentity, messageId);
@@ -1290,12 +1311,7 @@ export class OmpTimelineProjector {
     const nativeIdentity = assistantIdentity(message);
     if (this.stream && nativeIdentity && this.stream.nativeIdentity !== nativeIdentity) {
       if (!this.stream.nativeIdentity && !this.stream.published) {
-        const messageId = this.messageIdForNativeIdentity(nativeIdentity);
-        if (!messageId) {
-          this.stream = null;
-          return;
-        }
-        this.stream.messageId = messageId;
+        this.stream.messageId = this.messageIdForNativeIdentity(nativeIdentity);
         this.stream.nativeIdentity = nativeIdentity;
       } else {
         this.flush();
@@ -1303,7 +1319,6 @@ export class OmpTimelineProjector {
       }
     }
     const stream = this.stream ?? this.beginStream(message, turnId);
-    if (!stream) return;
     if (update?.contentIndex !== undefined) {
       this.updateBlock(stream, message, update.contentIndex, update);
       return;

package/server/subagents.ts

@@ -0,0 +1,97 @@
+import type { RpcInput, RpcOutput } from "@getpaseo/plugin";
+import type { cancelOmpSubagent, steerOmpSubagent } from "../shared/subagents";
+import { OmpRpcRequestRejectedError } from "./provider/omp-rpc-transport";
+import { isOmpPublicError, OmpPublicError } from "./provider/security";
+
+/** Subagent controls of one live OMP session; history-only sessions never register. */
+export interface OmpSubagentControls {
+  /** Resolves `false` when the subagent is no longer running. */
+  cancelSubagent(handle: string): Promise<boolean>;
+  steerSubagent(handle: string, message: string): Promise<void>;
+}
+
+export class OmpSubagentNotRunningError extends OmpPublicError {
+  constructor() {
+    super("This subagent is no longer running");
+  }
+}
+
+type SubagentOperation = "cancel" | "steer";
+
+const OPERATION_FAILURES: Record<SubagentOperation, string> = {
+  cancel: "OMP could not cancel the subagent",
+  steer: "OMP did not accept the message. The subagent may have finished or refused it",
+};
+
+// A timed-out request is not withdrawn from OMP, so its outcome is unknown rather than failed.
+const OPERATION_TIMEOUTS: Record<SubagentOperation, string> = {
+  cancel: "OMP did not confirm the cancellation in time. Check the subagent before retrying",
+  steer: "OMP did not confirm delivery in time. The subagent may still receive the message",
+};
+
+/**
+ * Routes subagent controls to the OMP session that owns a Paseo agent. Keys are the agent ID the
+ * plugin's own `agent.session_open` hook injects, so a request can only reach that agent's
+ * runtime, and OMP then resolves the subagent only within that runtime's roster.
+ */
+export class OmpSubagentControlRegistry {
+  private readonly agents = new Map<string, { controls: OmpSubagentControls }>();
+
+  /** A newer session for the same agent replaces the older one; its removal is then a no-op. */
+  register(agentId: string, controls: OmpSubagentControls): () => void {
+    const entry = { controls };
+    this.agents.set(agentId, entry);
+    return () => {
+      if (this.agents.get(agentId) === entry) this.agents.delete(agentId);
+    };
+  }
+
+  get(agentId: string): OmpSubagentControls | undefined {
+    return this.agents.get(agentId)?.controls;
+  }
+
+  clear(): void {
+    this.agents.clear();
+  }
+}
+
+async function withPublicFailure<T>(operation: SubagentOperation, run: () => Promise<T>) {
+  try {
+    return await run();
+  } catch (error) {
+    if (isOmpPublicError(error)) throw error;
+    if (error instanceof OmpRpcRequestRejectedError && error.code === "unsupported_command") {
+      throw new OmpPublicError("Update OMP to 18.4.9 or newer to control subagents from Paseo");
+    }
+    if (error instanceof Error && error.message === "OMP RPC request timed out") {
+      throw new OmpPublicError(OPERATION_TIMEOUTS[operation]);
+    }
+    // Native OMP error text is never forwarded; it can echo arbitrary subagent output.
+    throw new OmpPublicError(OPERATION_FAILURES[operation]);
+  }
+}
+
+function controlsFor(registry: OmpSubagentControlRegistry, agentId: string): OmpSubagentControls {
+  const controls = registry.get(agentId);
+  if (!controls) throw new OmpPublicError("This agent has no running OMP Plugin session");
+  return controls;
+}
+
+export async function resolveCancelOmpSubagent(
+  input: RpcInput<typeof cancelOmpSubagent>,
+  registry: OmpSubagentControlRegistry,
+): Promise<RpcOutput<typeof cancelOmpSubagent>> {
+  const controls = controlsFor(registry, input.agentId);
+  return {
+    cancelled: await withPublicFailure("cancel", () => controls.cancelSubagent(input.subagentId)),
+  };
+}
+
+export async function resolveSteerOmpSubagent(
+  input: RpcInput<typeof steerOmpSubagent>,
+  registry: OmpSubagentControlRegistry,
+): Promise<RpcOutput<typeof steerOmpSubagent>> {
+  const controls = controlsFor(registry, input.agentId);
+  await withPublicFailure("steer", () => controls.steerSubagent(input.subagentId, input.message));
+  return { accepted: true };
+}

package/shared/provider-launch-settings.ts

@@ -3,9 +3,13 @@ import { z } from "zod";
 
 export const MAX_INHERITED_ENVIRONMENT_NAMES = 256;
 export const environmentNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/u);
+export const DEFAULT_MAX_SESSIONS = 32;
+// Every allowed session can open at once without reaching the 128 in-flight operations bound.
+export const MAX_SESSIONS_UPPER_BOUND = 64;
 
 export const providerLaunchSettingsSchema = z.object({
   inheritEnv: z.array(environmentNameSchema).max(MAX_INHERITED_ENVIRONMENT_NAMES).default([]),
+  maxSessions: z.number().int().min(1).max(MAX_SESSIONS_UPPER_BOUND).default(DEFAULT_MAX_SESSIONS),
 });
 
 export type ProviderLaunchSettings = z.infer<typeof providerLaunchSettingsSchema>;

package/shared/subagents.ts

@@ -0,0 +1,60 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_SUBAGENT_STEER_MAX_LENGTH = 16_384;
+export const OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH = 512;
+
+const AgentIdSchema = z.string().min(1).max(256);
+const SubagentIdSchema = z.string().min(1).max(256);
+
+export const OmpSubagentStatusSchema = z.enum([
+  "pending",
+  "running",
+  "started",
+  "completed",
+  "failed",
+  "aborted",
+]);
+export type OmpSubagentStatus = z.infer<typeof OmpSubagentStatusSchema>;
+
+export const cancelOmpSubagent = defineRpc({
+  name: "paseo-omp.cancel-subagent",
+  input: z.object({ agentId: AgentIdSchema, subagentId: SubagentIdSchema }),
+  /** `false` when the subagent had already finished; cancelling is idempotent. */
+  output: z.object({ cancelled: z.boolean() }),
+});
+
+export const steerOmpSubagent = defineRpc({
+  name: "paseo-omp.steer-subagent",
+  input: z.object({
+    agentId: AgentIdSchema,
+    subagentId: SubagentIdSchema,
+    message: z.string().trim().min(1).max(OMP_SUBAGENT_STEER_MAX_LENGTH),
+  }),
+  output: z.object({ accepted: z.literal(true) }),
+});
+
+export const OMP_SUBAGENT_STRIP_KIND = "omp-subagents";
+export const MAX_OMP_SUBAGENT_STRIP_ENTRIES = 64;
+
+/** The running subagents of one `task` call, rendered below its tool card. */
+export const ompSubagentStripSchema = z.object({
+  subagents: z
+    .array(
+      z.object({
+        /** Opaque handle scoped to the agent's current OMP session, never the native OMP ID. */
+        id: SubagentIdSchema,
+        agent: z.string().min(1).max(256),
+        description: z.string().max(OMP_SUBAGENT_DESCRIPTION_MAX_LENGTH).nullable(),
+        /** Epoch milliseconds when the plugin last saw the subagent start running. */
+        runningSince: z.number().int().nonnegative(),
+      }),
+    )
+    .max(MAX_OMP_SUBAGENT_STRIP_ENTRIES),
+});
+export type OmpSubagentStrip = z.infer<typeof ompSubagentStripSchema>;
+
+/** OMP reaches a subagent only while its roster lists it as running or pending. */
+export function isLiveOmpSubagentStatus(status: OmpSubagentStatus): boolean {
+  return status === "pending" || status === "running";
+}