@omercnet/paseo-omp 5.1.1-next.336.1 → 5.1.1-next.340.1

package/server/provider/connection.ts

@@ -13,6 +13,7 @@ import type {
   OmpOperationalFailure,
   OmpOperationalFailureReporter,
 } from "../operational-failure-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { discoverOmpCatalog } from "./catalog";
 import { normalizeOmpCatalogOptions } from "./config-normalization";
 import type { OmpMcpConnector } from "./host-tools";
@@ -724,6 +725,7 @@ export function createOmpConnection(
   reportOperationalFailure: OmpOperationalFailureReporter = () => {},
   resolveHostInheritEnv?: () => Promise<readonly string[]>,
   sessionLimit = new OmpSessionLimit(),
+  subagentControlRegistry?: OmpSubagentControlRegistry,
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -758,6 +760,7 @@ export function createOmpConnection(
       session: OmpOpenedSession;
       nativeSessionId?: string;
       removeBrowserAuthorization?: () => void;
+      removeSubagentControls?: () => void;
     }
   >();
   const opening = new Map<
@@ -791,6 +794,7 @@ export function createOmpConnection(
     if (slot?.token !== token) return false;
     sessions.delete(sessionId);
     slot.removeBrowserAuthorization?.();
+    slot.removeSubagentControls?.();
     return true;
   };
 
@@ -1033,12 +1037,12 @@ export function createOmpConnection(
             nativeReservations.release(nativeSessionId, token);
             return;
           }
-          const browserAgentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
+          const agentId = input.config.env.PASEO_AGENT_ID?.trim() || input.sessionId;
           // A history session has no live Paseo browser tools to authorize.
           const browserAuthorization = historyOnly
             ? undefined
             : browserAuthorizationRegistry?.register(
-                browserAgentId,
+                agentId,
                 session.openPaseoBrowser.bind(session),
               );
           session.setBrowserAuthorizationIssuer(browserAuthorization?.issue ?? null);
@@ -1048,11 +1052,17 @@ export function createOmpConnection(
                 browserAuthorization.remove();
               }
             : undefined;
+          // A history session has no runtime, so it has no subagents to control.
+          const removeSubagentControls =
+            session instanceof OmpProviderSession
+              ? subagentControlRegistry?.register(agentId, session)
+              : undefined;
           sessions.set(input.sessionId, {
             token,
             session,
             nativeSessionId,
             ...(removeBrowserAuthorization ? { removeBrowserAuthorization } : {}),
+            ...(removeSubagentControls ? { removeSubagentControls } : {}),
           });
           await session.publishOpened(input.requestId);
           if (
@@ -1204,7 +1214,10 @@ export function createOmpConnection(
     shutdown.abort(shutdownReason);
     for (const { controller } of opening.values()) controller.abort(shutdownReason);
     for (const { session } of sessions.values()) session.beginConnectionShutdown();
-    for (const slot of sessions.values()) slot.removeBrowserAuthorization?.();
+    for (const slot of sessions.values()) {
+      slot.removeBrowserAuthorization?.();
+      slot.removeSubagentControls?.();
+    }
     const failures: unknown[] = [];
     const operationBatch = [...activeOperations];
     const operationResults = await Promise.allSettled(operationBatch);

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

@@ -71,6 +71,8 @@ export const OMP_SESSION_EVENT_POLICIES = {
   tool_execution_end: "normalize",
   auto_compaction_start: "normalize",
   auto_compaction_end: "normalize",
+  manual_compaction_start: "normalize",
+  manual_compaction_end: "normalize",
   auto_retry_start: "normalize",
   auto_retry_end: "normalize",
   retry_fallback_applied: "normalize",
@@ -142,15 +144,21 @@ export const OMP_RPC_COMMAND_POLICIES = {
   abort_and_restore_queue: "unsupported",
   btw: "unsupported",
   btw_cancel: "unsupported",
-  cancel_subagent: "unsupported",
+  cancel_subagent: "implemented",
   fork: "unsupported",
   get_btw_history: "unsupported",
   get_logout_accounts: "unsupported",
   goal: "unsupported",
   live_mute: "unsupported",
+  live_connect: "unsupported",
   live_start: "unsupported",
   live_stop: "unsupported",
   logout: "unsupported",
+  navigate_tree: "unsupported",
+  abort_branch_summary: "unsupported",
+  set_label: "unsupported",
+  dictation_start: "unsupported",
+  dictation_stop: "unsupported",
   predict_word: "unsupported",
   predict_word_feedback: "unsupported",
   promote_queued_message: "unsupported",
@@ -158,7 +166,7 @@ export const OMP_RPC_COMMAND_POLICIES = {
   set_ask_dialog: "implemented",
   set_cache_warming: "unsupported",
   set_slow_mode: "unsupported",
-  steer_subagent: "unsupported",
+  steer_subagent: "implemented",
 } as const;
 export const OMP_RPC_RESPONSE_POLICIES = OMP_RPC_COMMAND_POLICIES;
 export const OMP_PROTOCOL_VIOLATION_CATEGORIES = [
@@ -254,9 +262,14 @@ export const OMP_PROTOCOL_EVENT_TYPES = [
   "todo_auto_clear",
   "auto_compaction_start",
   "auto_compaction_end",
+  "manual_compaction_start",
+  "manual_compaction_end",
   "available_commands_update",
   "notice",
   "command_output",
+  "extension_error",
+  "session_info_update",
+  "config_update",
   "extension_ui_request",
   "prompt_result",
   "host_tool_call",
@@ -403,6 +416,8 @@ function eventSchemaClassification(
     case "cache_warming_start":
     case "cache_warming_end":
     case "queue_update":
+    case "session_info_update":
+    case "config_update":
       return { reason: "configuration-event-schema", expected: "valid-configuration-event" };
     case "extension_ui_request":
       return { reason: "extension-ui-schema", expected: "valid-extension-ui-event" };
@@ -1606,6 +1621,17 @@ const OmpAgentSessionEventSchema = z.discriminatedUnion("type", [
     errorMessage: boundedString(64 * 1024).optional(),
     skipped: z.boolean().optional(),
   }),
+  z.object({
+    type: z.literal("manual_compaction_start"),
+    mode: boundedString(MAX_CONFIG_EVENT_TEXT_BYTES).optional(),
+  }),
+  z.object({
+    type: z.literal("manual_compaction_end"),
+    result: OmpCompactionResultSchema.optional(),
+    aborted: z.boolean(),
+    skipped: z.boolean().optional(),
+    errorMessage: boundedString(64 * 1024).optional(),
+  }),
   z.object({
     type: z.literal("notice"),
     id: IDENTIFIER.optional(),
@@ -1799,6 +1825,14 @@ export const OmpRuntimeEventSchema = z.discriminatedUnion("type", [
     commands: z.array(OmpAvailableCommandSchema).max(MAX_ARRAY_ITEMS),
   }),
   z.object({ type: z.literal("command_output"), text: TEXT.optional() }),
+  z.object({
+    type: z.literal("extension_error"),
+    extensionPath: boundedString(MAX_PATH_LENGTH),
+    event: NAME,
+    error: boundedString(64 * 1024),
+  }),
+  z.object({ type: z.literal("session_info_update") }),
+  z.object({ type: z.literal("config_update") }),
   OmpExtensionUiRequestSchema,
   z.object({
     type: z.literal("prompt_result"),
@@ -1967,6 +2001,8 @@ export const OmpSubagentsResultSchema = z.object({
     )
     .max(1_024),
 });
+export const OmpCancelSubagentResultSchema = z.object({ cancelled: z.boolean() });
+export const OmpSteerSubagentResultSchema = z.object({}).strict().optional();
 export const OmpSubagentMessagesResultSchema = z.object({
   sessionFile: boundedString(MAX_PATH_LENGTH),
   fromByte: z.number().int().nonnegative(),
@@ -1997,6 +2033,7 @@ export function parseOmpHostToolAgentResult(value: unknown): OmpHostToolResult["
 export type OmpRpcEvent =
   | z.infer<typeof OmpRuntimeEventSchema>
   | { type: "prompt_error"; id: string; error: string; code?: string }
+  | { type: "session_settled" }
   | { type: "process_exit"; error: string };
 export type OmpAgentSessionEvent = z.infer<typeof OmpAgentSessionEventSchema>;
 export type OmpSubagentSnapshot = z.infer<typeof OmpSubagentsResultSchema>["subagents"][number];

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

@@ -1090,8 +1090,11 @@ export class OmpRpcProcess {
       });
       return;
     }
-    // Emitted once the session has no live or background work. Nothing consumes it yet.
-    if (type === "session_settled") return;
+    // Emitted when the session is quiet: nothing live, queued, or pending in the background.
+    if (type === "session_settled") {
+      this.emit({ type: "session_settled" });
+      return;
+    }
     if (type === "ready") {
       if (this.readyReceived) {
         this.recordProtocolViolation("duplicate-ready", {

package/server/provider/omp-rpc.ts

@@ -16,6 +16,7 @@ import {
   OmpBranchMessagesResultSchema,
   type OmpBranchResult,
   OmpBranchResultSchema,
+  OmpCancelSubagentResultSchema,
   type OmpCompactionResult,
   OmpCompactionResultSchema,
   type OmpExtensionUiResponse,
@@ -41,6 +42,7 @@ import {
   OmpSessionStateSchema,
   type OmpSessionStats,
   OmpSessionStatsSchema,
+  OmpSteerSubagentResultSchema,
   type OmpSubagentMessagesResult,
   OmpSubagentMessagesResultSchema,
   type OmpSubagentSnapshot,
@@ -105,6 +107,9 @@ export interface OmpRuntimeSession {
     subagentId?: string;
     sessionFile?: string;
   }): Promise<OmpSubagentMessagesResult>;
+  /** Resolves `false` when OMP no longer lists the subagent as running for this session. */
+  cancelSubagent(subagentId: string): Promise<boolean>;
+  steerSubagent(subagentId: string, message: string): Promise<void>;
   prompt(
     message: string,
     images?: readonly OmpImage[],
@@ -466,6 +471,26 @@ class OmpRpcSession implements OmpRuntimeSession {
     );
   }
 
+  async cancelSubagent(subagentId: string): Promise<boolean> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    return OmpCancelSubagentResultSchema.parse(
+      await this.process.request({ type: "cancel_subagent", subagentId: safeId }),
+    ).cancelled;
+  }
+
+  async steerSubagent(subagentId: string, message: string): Promise<void> {
+    const safeId = validateBoundedText(subagentId, "subagent identifier", MAX_ID_LENGTH);
+    const safeMessage = validateBoundedText(message, "subagent steering message", MAX_TEXT_LENGTH);
+    if (!safeMessage.trim()) throw new Error("Invalid OMP subagent steering message");
+    OmpSteerSubagentResultSchema.parse(
+      await this.process.request({
+        type: "steer_subagent",
+        subagentId: safeId,
+        message: safeMessage,
+      }),
+    );
+  }
+
   async getBranchMessages(): Promise<Array<{ entryId: string; text: string }>> {
     const result = OmpBranchMessagesResultSchema.parse(
       await this.process.request({ type: "get_branch_messages" }),

package/server/provider/registration.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
 import type { OmpOperationalFailureReporter } from "../operational-failure-diagnostics";
 import { probeOmpAvailability } from "../provider-diagnostics";
+import type { OmpSubagentControlRegistry } from "../subagents";
 import { mergeOmpInheritedEnvironmentNames } from "./config-normalization";
 import { createOmpConnection, OmpNativeSessionReservations } from "./connection";
 import type { OmpMcpConnector } from "./host-tools";
@@ -131,6 +132,7 @@ export interface OmpProviderOptions {
     timeoutMs: number | undefined,
   ) => Promise<ProviderAvailabilityCompat>;
   resolveHostInheritEnv?: () => Promise<readonly string[]>;
+  subagentControlRegistry?: OmpSubagentControlRegistry;
 }
 
 function stableJson(value: unknown): string {
@@ -235,6 +237,7 @@ export function createOmpProvider(options: OmpProviderOptions = {}): ProviderReg
         options.reportOperationalFailure,
         options.resolveHostInheritEnv,
         sessionLimit,
+        options.subagentControlRegistry,
       );
     },
   };

package/server/provider/session-compaction.ts

@@ -7,6 +7,7 @@ import type { OmpSessionUsage } from "./session-usage";
 import type { OmpTimelineProjector } from "./timeline-projector";
 
 type Emit = (event: ProviderEvent) => void;
+export type CompactionOutcome = "completed" | "failed" | "canceled" | "skipped";
 
 export interface ActiveCompaction {
   id: string;
@@ -73,51 +74,54 @@ export class OmpSessionCompaction {
     });
   }
 
-  handleAutoEnd(
+  handleEnd(
     turn: ActiveTurn,
-    event: Extract<OmpRpcEvent, { type: "auto_compaction_end" }>,
-  ): boolean {
+    event: Extract<OmpRpcEvent, { type: "auto_compaction_end" | "manual_compaction_end" }>,
+  ): CompactionOutcome | undefined {
     if (this.discardedEnds > 0) {
       this.discardedEnds -= 1;
-      return false;
+      return undefined;
     }
     const operation = this.operation;
+    const trigger = event.type === "auto_compaction_end" ? "auto" : "manual";
     if (
-      operation?.trigger !== "auto" ||
+      operation?.trigger !== trigger ||
       operation.turnId !== turn.turnId ||
       operation.generation !== turn.generation
     ) {
-      return false;
+      return undefined;
     }
-    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;
+    if (event.type === "auto_compaction_end") {
+      if (event.action !== undefined && operation.action !== event.action) {
+        this.retire("OMP emitted overlapping compactions");
+        this.discardedEnds = 1;
+        return undefined;
+      }
+      if (event.willRetry) {
+        operation.retrying = true;
+        return undefined;
+      }
+      if (operation.retrying) {
+        operation.retrying = false;
+        return undefined;
+      }
     }
-    const state = event.aborted
+    const state: CompactionOutcome = event.aborted
       ? "canceled"
-      : event.errorMessage
-        ? "failed"
-        : event.skipped
-          ? "skipped"
+      : event.skipped
+        ? "skipped"
+        : event.errorMessage
+          ? "failed"
           : "completed";
     this.finish(state, {
       tokensBefore: event.result?.tokensBefore ?? event.result?.preTokens,
       message: event.errorMessage,
     });
-    return true;
+    return state;
   }
 
   finish(
-    state: "completed" | "failed" | "canceled" | "skipped",
+    state: CompactionOutcome,
     options: { tokensBefore?: number | null; message?: string } = {},
   ): void {
     const operation = this.operation;

package/server/provider/session-events.ts

@@ -24,6 +24,7 @@ export function isRuntimeConfigEvent(event: OmpRpcEvent): boolean {
   return (
     event.type === "model_changed" ||
     event.type === "thinking_level_changed" ||
+    event.type === "config_update" ||
     event.type === "retry_fallback_applied" ||
     event.type === "retry_fallback_succeeded"
   );

package/server/provider/session-terminal.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import type { ProviderError } from "@getpaseo/plugin/server/provider";
 import type { OmpMessage, OmpRpcEvent } from "./omp-rpc-protocol";
+import type { CompactionOutcome } from "./session-compaction";
 
 export type PendingUser = {
   clientMessageId: string;
@@ -12,7 +13,7 @@ export type PendingUser = {
 type TerminalCorrelationEvidence = "fresh-native-user" | "current-assistant";
 
 type TerminalCorrelation = {
-  policy: "initial-turn" | "ordered-legacy" | "native-command";
+  policy: "initial-turn" | "ordered-legacy" | "native-command" | "native-run";
   evidence: Map<TerminalCorrelationEvidence, number>;
 };
 
@@ -24,6 +25,7 @@ export type TerminalCandidate = {
     | "initial-turn"
     | "ordered-legacy"
     | "native-command"
+    | "native-run"
     | "interrupted"
     | "ambiguous";
 };
@@ -55,6 +57,7 @@ export type ActiveTurn = {
   usageSampleFloor: number;
   manualCompaction: boolean;
   manualCompactionPending: boolean;
+  manualCompactionOutcome?: CompactionOutcome;
   manualCompactionDeadlineTimer?: unknown;
   agentEndPending: boolean;
   agentEndRetryTimer?: unknown;
@@ -64,11 +67,14 @@ export type ActiveTurn = {
   terminalizing: boolean;
   terminalization?: Promise<void>;
   terminalOutcome?: TurnOutcome;
+  /** Listeners may hold this turn's terminal state from here on, even if publishing threw. */
+  terminalEmitAttempted: boolean;
   operationalTerminalStage?: "failed" | "unresolved";
   terminalWake?: VoidDeferred;
   steerReady: VoidDeferred;
   steersInFlight: number;
   deferredAgentEnd?: TerminalCandidate;
+  heldAgentEnd?: HeldAgentEnd;
   activeToolCallIds: Set<string>;
   bufferedEvents: OmpRpcEvent[];
   pendingUsers: PendingUser[];
@@ -82,6 +88,38 @@ export type ActiveTurn = {
   lastCompletedAssistantEntryId?: string;
 };
 
+type RunEvidence = Pick<
+  ActiveTurn,
+  | "completedMessageCount"
+  | "streamedMessageEntryIds"
+  | "streamedMessageIdentityComplete"
+  | "lastCompletedAssistantOutcome"
+  | "lastCompletedAssistantEntryId"
+>;
+
+/** A run that ended with `isTerminal: false`, kept until another run starts or OMP settles. */
+export type HeldAgentEnd = {
+  event: Extract<OmpRpcEvent, { type: "agent_end" }>;
+  arrivalSequence: number;
+  evidence: RunEvidence;
+};
+
+/** Hands over the evidence of the run that just ended and starts the next run's evidence empty. */
+export function takeRunEvidence(turn: ActiveTurn): RunEvidence {
+  const evidence: RunEvidence = {
+    completedMessageCount: turn.completedMessageCount,
+    streamedMessageEntryIds: turn.streamedMessageEntryIds.splice(0),
+    streamedMessageIdentityComplete: turn.streamedMessageIdentityComplete,
+    lastCompletedAssistantOutcome: turn.lastCompletedAssistantOutcome,
+    lastCompletedAssistantEntryId: turn.lastCompletedAssistantEntryId,
+  };
+  turn.completedMessageCount = 0;
+  turn.streamedMessageIdentityComplete = true;
+  turn.lastCompletedAssistantOutcome = undefined;
+  turn.lastCompletedAssistantEntryId = undefined;
+  return evidence;
+}
+
 export type VoidDeferred = {
   promise: Promise<void>;
   resolve(value?: void | PromiseLike<void>): void;
@@ -249,6 +287,7 @@ export function createActiveTurn(
     usageSampleFloor: 0,
     agentEndPending: false,
     terminalizing: false,
+    terminalEmitAttempted: false,
     manualCompactionPending: manualCompaction,
     manualCompaction,
     activitySequence: 0,
@@ -276,6 +315,15 @@ export function createActiveTurn(
     ],
   };
 }
+/** A run OMP started without a client prompt: an extension, goal, or background wake. */
+export function createNativeRunTurn(generation: number): ActiveTurn {
+  return {
+    ...createActiveTurn("", "", generation, "native-run"),
+    promptResultEmitted: true,
+    pendingUsers: [],
+  };
+}
+
 export function classifyTerminalCandidate(
   turn: ActiveTurn,
   event: Extract<OmpRpcEvent, { type: "agent_end" }>,
@@ -286,6 +334,9 @@ export function classifyTerminalCandidate(
   if (turn.terminalCorrelation.policy === "initial-turn") {
     return { event, confidence: "initial-turn", arrivalSequence };
   }
+  if (turn.terminalCorrelation.policy === "native-run") {
+    return { event, confidence: "native-run", arrivalSequence };
+  }
   const assistantSequence = turn.terminalCorrelation.evidence.get("current-assistant");
   if (
     turn.terminalCorrelation.policy === "native-command" &&