paseo-dsh-direct 0.2.13 → 0.2.14

package/OVERVIEW.md

@@ -14,6 +14,7 @@ Runs DeepSeek Harness (`dsh`) as a native Paseo agent provider. Paseo clients (d
 - Create, resume, cancel and close sessions; model list and mode switching from the Paseo UI.
 - Token usage and context-window fill in Paseo's usage meter.
 - DSH branding (name and icon) in the provider list.
+- On Paseo 0.14, answers the host's idle runtime cleanup query and refuses cleanup while supported DSH checks find pending work (agents, inboxes, maintenance, background jobs, subagent completion delivery, goals, reminders). After the host releases a persisted session runtime, the next message resumes the same native DSH session.
 
 ## Processes and environment
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo-dsh-direct",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "DeepSeek Harness Direct Provider Plugin for Paseo",
   "repository": {
     "type": "git",
@@ -33,8 +33,8 @@
     "!server/generated-version.ts"
   ],
   "peerDependencies": {
-    "@getpaseo/client": "0.12.0",
-    "@getpaseo/protocol": "0.12.0",
+    "@getpaseo/client": "0.14.0",
+    "@getpaseo/protocol": "0.14.0",
     "react": "~19.1.0",
     "react-native": ">=0.81.5",
     "zod": "^4.4.3"
@@ -57,7 +57,7 @@
     }
   },
   "devDependencies": {
-    "@getpaseo/plugin": "0.12.0",
+    "@getpaseo/plugin": "0.14.0",
     "@tanstack/react-query": "^5.105.0",
     "@types/mdast": "^4.0.4",
     "@types/node": "^24.0.0",

package/server/dsh/bridge.ts

@@ -45,6 +45,7 @@ const METHODS = new Set<keyof BridgeMethods>([
   "session.commands",
   "session.command",
   "session.cancel",
+  "session.can_stop_runtime",
   "interaction.respond",
 ]);
 

package/server/dsh/host.ts

@@ -30,6 +30,10 @@ export interface HostAgent {
   id: string;
   ctx: HostContext;
   session: HostSession;
+  inbox?: {
+    readonly nextTurn: readonly unknown[];
+    readonly nextStep: readonly unknown[];
+  };
   options: ModelSelection;
   status: "idle" | "running";
   followup(message: unknown): void;
@@ -92,6 +96,8 @@ export interface HostServices {
   };
   agents: {
     get(id: string): HostAgent | undefined;
+    list?(): HostAgent[];
+    isOwnedBy?(id: string, owner: HostAgent): boolean;
     create(options: AgentOptions): Promise<HostHandle>;
     resume(options: AgentOptions): Promise<HostHandle>;
   };
@@ -199,6 +205,28 @@ export interface HostServices {
       | undefined
     >;
   };
+  jobs?: {
+    list(
+      caller?: string,
+    ): Array<{
+      id: string;
+      owner?: string;
+      status: "running" | "stopping" | "completed" | "killed" | "failed";
+    }>;
+  };
+  goals?: {
+    get(
+      agent: HostAgent,
+    ):
+      | {
+          phase?: string;
+          activation?: string;
+        }
+      | undefined;
+  };
+  schedule?: {
+    list(request: { sessionId: string }): Promise<readonly unknown[]>;
+  };
   userQuestions: object | undefined;
   appReady: { onReady(listener: () => void): () => void } | undefined;
   appExit: ((code: number) => void) | undefined;
@@ -216,6 +244,7 @@ export interface HostHelpers {
 export type ApprovalOutcome =
   "allowed-once" | "rejected" | "cancelled" | "unavailable";
 export interface HostEvents {
+  "schedule/changed": () => void;
   "session/created": (session: HostSession) => void;
   "session/event": (session: HostSession, event: DshSessionEvent) => void;
   "agent/assistant-stream": (payload: {
@@ -244,4 +273,16 @@ export interface HostEvents {
     },
     next: () => Promise<{ answers: QuestionAnswer[] }>,
   ) => Promise<{ answers: QuestionAnswer[] }>;
+  "subagent/start": (info: {
+    runId: string;
+    id: string;
+    provider?: string;
+    local?: boolean;
+  }) => void;
+  "subagent/end": (info: {
+    runId: string;
+    id: string;
+    provider?: string;
+    local?: boolean;
+  }) => void;
 }

package/server/dsh/runtime-safety.ts

@@ -0,0 +1,244 @@
+import type { HostAgent, HostContext } from "./host.js";
+
+/**
+ * Tracks published subagent runs between `subagent/start` and `subagent/end`.
+ *
+ * The subagent manager emits `subagent/end` only after an activation's
+ * teardown finishes, its completion notice is delivered to the parent inbox,
+ * and parent ownership is released. While a run is in this table, stopping the
+ * bridge would lose an external child or a local child's settlement notice.
+ */
+export class SubagentRunTracker {
+  private readonly activeByRoot = new Map<string, Set<string>>();
+  private readonly rootByRun = new Map<string, string | undefined>();
+
+  /**
+   * Subscribe inside a root session's `setup(agentCtx)` so direct delegations
+   * of that root always resolve to `rootId`, even for external backends whose
+   * child id is not in `ctx.agents` or `session/created`.
+   */
+  observeRootScope(rootId: string, agentCtx: HostContext): void {
+    agentCtx.on("subagent/start", (info) => {
+      if (typeof info?.runId === "string" && info.runId) {
+        this.startRun(rootId, info.runId);
+      }
+    });
+    agentCtx.on("subagent/end", (info) => {
+      if (typeof info?.runId === "string" && info.runId) {
+        this.endRun(info.runId);
+      }
+    });
+  }
+
+  /**
+   * Observe every process-level run, including external children whose parent
+   * is outside the bridge-owned session tree.
+   */
+  observeHost(
+    ctx: HostContext,
+    resolveRoot: (childId: string) => string | undefined,
+  ): Array<() => void> {
+    return [
+      ctx.on("subagent/start", (info) => {
+        if (typeof info?.runId !== "string" || !info.runId) return;
+        if (this.rootByRun.has(info.runId)) return;
+        const rootId =
+          typeof info.id === "string" ? resolveRoot(info.id) : undefined;
+        this.startRun(rootId, info.runId);
+      }),
+      ctx.on("subagent/end", (info) => {
+        if (typeof info?.runId === "string" && info.runId) {
+          this.endRun(info.runId);
+        }
+      }),
+    ];
+  }
+
+  hasActiveRuns(rootId?: string): boolean {
+    return rootId === undefined
+      ? this.rootByRun.size > 0
+      : (this.activeByRoot.get(rootId)?.size ?? 0) > 0;
+  }
+
+  clearRoot(rootId: string): void {
+    const runs = this.activeByRoot.get(rootId);
+    if (runs) {
+      for (const runId of runs) this.rootByRun.delete(runId);
+      this.activeByRoot.delete(rootId);
+    }
+  }
+
+  clearAll(): void {
+    this.activeByRoot.clear();
+    this.rootByRun.clear();
+  }
+
+  private startRun(rootId: string | undefined, runId: string): void {
+    const existing = this.rootByRun.get(runId);
+    if (existing && existing !== rootId) {
+      this.activeByRoot.get(existing)?.delete(runId);
+    }
+    this.rootByRun.set(runId, rootId);
+    if (rootId === undefined) return;
+    let set = this.activeByRoot.get(rootId);
+    if (!set) {
+      set = new Set();
+      this.activeByRoot.set(rootId, set);
+    }
+    set.add(runId);
+  }
+
+  private endRun(runId: string): void {
+    const rootId = this.rootByRun.get(runId);
+    this.rootByRun.delete(runId);
+    if (!rootId) return;
+    const set = this.activeByRoot.get(rootId);
+    if (!set) return;
+    set.delete(runId);
+    if (set.size === 0) this.activeByRoot.delete(rootId);
+  }
+}
+
+export interface RuntimeSafetyInput {
+  ctx: HostContext;
+  sessionId: string;
+  rootAgent: HostAgent | undefined;
+  hasBridgeActivity: () => boolean;
+  hasActiveSubagentRuns: () => boolean;
+}
+
+/**
+ * Decide whether releasing this DSH session runtime loses in-flight work.
+ *
+ * This query is strictly read-only: it never cancels, disposes, mutates, or
+ * leaves behind uncancelled listeners. Any missing required inspection surface
+ * or thrown error fails closed (`false`).
+ */
+export async function canStopSessionRuntime(
+  input: RuntimeSafetyInput,
+): Promise<boolean> {
+  let disposeScheduleObserver: (() => void) | undefined;
+  try {
+    if (input.hasBridgeActivity() || input.hasActiveSubagentRuns()) return false;
+    const root = input.rootAgent;
+    if (!root || String(root.id) !== input.sessionId) return false;
+    const agents = input.ctx.get("agents");
+    const jobs = input.ctx.get("jobs");
+    const goals = input.ctx.get("goals");
+    const schedule = input.ctx.get("schedule");
+    if (
+      !agents ||
+      typeof agents.get !== "function" ||
+      typeof agents.list !== "function" ||
+      !jobs ||
+      typeof jobs.list !== "function" ||
+      (goals && typeof goals.get !== "function") ||
+      (schedule && typeof schedule.list !== "function")
+    ) {
+      return false;
+    }
+
+    let scheduleChanged = false;
+    if (schedule) {
+      disposeScheduleObserver = input.ctx.on("schedule/changed", () => {
+        scheduleChanged = true;
+      });
+    }
+    // Stopping the bridge exits the entire DSH process, including agents
+    // started by the profile or schedule runtime outside this session's tree.
+    const readAgents = (): HostAgent[] => {
+      if (agents.get(input.sessionId) !== root) return [];
+      const live = agents.list!();
+      return Array.isArray(live) && live.includes(root) ? live : [];
+    };
+    const liveAgents = readAgents();
+    if (liveAgents.length === 0 || !(await areAgentsQuiescent(liveAgents))) return false;
+    if (schedule) {
+      for (const agent of liveAgents) {
+        const active = await schedule.list({ sessionId: String(agent.id) });
+        if (!Array.isArray(active) || active.length > 0) return false;
+      }
+    }
+
+    // Schedule reads yield to arbitrary runtime work. Probe maintenance again,
+    // then re-read every synchronous veto before returning the decision.
+    if (!(await areAgentsQuiescent(liveAgents))) return false;
+    const currentAgents = readAgents();
+    if (
+      scheduleChanged ||
+      input.hasBridgeActivity() ||
+      input.hasActiveSubagentRuns() ||
+      currentAgents.length !== liveAgents.length ||
+      currentAgents.some((agent) => !liveAgents.includes(agent))
+    ) {
+      return false;
+    }
+    for (const agent of liveAgents) {
+      if (!isAgentSynchronouslyIdle(agent)) return false;
+      const goal = goals?.get(agent);
+      if (goal?.phase === "active" && goal.activation === "armed") return false;
+    }
+    // No caller filter: jobs can outlive their owner agent's registry entry.
+    const views = jobs.list();
+    if (
+      !Array.isArray(views) || views.some(
+        (job) => job?.status === "running" || job?.status === "stopping",
+      )
+    ) return false;
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      disposeScheduleObserver?.();
+    } catch {
+      return false;
+    }
+  }
+}
+
+function isAgentSynchronouslyIdle(agent: HostAgent): boolean {
+  if (agent.status !== "idle") return false;
+  const inbox = agent.inbox;
+  if (
+    !inbox ||
+    !Array.isArray(inbox.nextTurn) ||
+    !Array.isArray(inbox.nextStep)
+  ) {
+    return false;
+  }
+  return inbox.nextTurn.length === 0 && inbox.nextStep.length === 0;
+}
+
+// Repeated safety queries during a long maintenance job must not attach another
+// whenIdle continuation to the same unfinished activity on every request.
+const idleObservations = new WeakMap<
+  HostAgent,
+  { state: "pending" | "idle" | "failed" }
+>();
+
+async function areAgentsQuiescent(agents: readonly HostAgent[]): Promise<boolean> {
+  const observations = [];
+  for (const agent of agents) {
+    if (!isAgentSynchronouslyIdle(agent) || typeof agent.whenIdle !== "function") {
+      return false;
+    }
+    let observation = idleObservations.get(agent);
+    if (!observation || observation.state !== "pending") {
+      observation = { state: "pending" };
+      idleObservations.set(agent, observation);
+      const current = observation;
+      void Promise.resolve(agent.whenIdle()).then(
+        () => { current.state = "idle"; },
+        () => { current.state = "failed"; },
+      );
+    }
+    observations.push(observation);
+  }
+  // DSH's async whenIdle awaits activityDone and checks that its identity has
+  // not changed. Allow that resolved-promise path to finish without waiting for
+  // pending maintenance, timers, or attaching listeners to a long-lived race.
+  await Promise.resolve().then(() => undefined).then(() => undefined);
+  return observations.every((observation) => observation.state === "idle") &&
+    agents.every(isAgentSynchronouslyIdle);
+}

package/server/dsh/service.ts

@@ -19,6 +19,7 @@ import type {
   SlashCommand,
 } from "../../shared/bridge-protocol.js";
 import { SubagentSettings } from "./subagent-settings.js";
+import { canStopSessionRuntime, SubagentRunTracker } from "./runtime-safety.js";
 import { slashLine } from "../../shared/bridge-protocol.js";
 import type {
   ApprovalOutcome,
@@ -147,6 +148,7 @@ export class BridgeService {
   private stopTask?: Promise<{}>;
   private readonly subagentSettings: SubagentSettings;
   private subagentSettingsInitializationError?: Error;
+  private readonly subagentRuns = new SubagentRunTracker();
 
   constructor(
     private readonly ctx: HostContext,
@@ -157,11 +159,12 @@ export class BridgeService {
     this.subagentSettings = new SubagentSettings(ctx, profile);
     this.subscriptions.push(
       ctx.on("session/created", (session) => {
-        if (session.header.parentSession)
+        if (session.header.parentSession) {
           this.parent.set(
             String(session.id),
             String(session.header.parentSession),
           );
+        }
       }),
     );
     this.subscriptions.push(
@@ -237,6 +240,11 @@ export class BridgeService {
         });
       }),
     );
+    this.subscriptions.push(
+      ...this.subagentRuns.observeHost(ctx, (childId) =>
+        this.rootForId(childId),
+      ),
+    );
   }
 
   /**
@@ -316,13 +324,19 @@ export class BridgeService {
   }
 
   private rootFor(agent: HostAgent | undefined): string | undefined {
-    let id = agent?.id && String(agent.id);
+    return agent && this.rootForId(String(agent.id), agent);
+  }
+
+  private rootForId(
+    sessionId: string,
+    agent = this.ctx.get("agents")?.get(sessionId),
+  ): string | undefined {
+    let id: string | undefined = sessionId;
     const seen = new Set<string>();
     while (id && !seen.has(id)) {
       if (this.tracked.has(id)) return id;
       seen.add(id);
-      id =
-        this.parent.get(id) ??
+      id = this.parent.get(id) ??
         (id === agent?.id ? agent.session.header.parentSession : undefined);
     }
     return undefined;
@@ -581,6 +595,13 @@ export class BridgeService {
         );
         result = {};
         break;
+      case "session.can_stop_runtime":
+        result = {
+          canStop: await this.canStopRuntime(
+            nonempty(params.sessionId, "sessionId"),
+          ),
+        };
+        break;
       case "session.close":
         await this.close(nonempty(params.sessionId, "sessionId"));
         result = {};
@@ -815,6 +836,7 @@ export class BridgeService {
         this.tracked.delete(id);
         this.preapproved.delete(id);
         this.lastUsage.delete(id);
+        this.subagentRuns.clearRoot(id);
       },
     );
     return task;
@@ -853,6 +875,7 @@ export class BridgeService {
       assembled: undefined,
     };
     const setup = async (agentCtx: HostContext) => {
+      this.subagentRuns.observeRootScope(id, agentCtx);
       this.helpers?.installModelSelection(agentCtx, modelRef);
       await presets.mount(agentCtx, preset.id);
       if (params.systemPrompt) {
@@ -950,6 +973,23 @@ export class BridgeService {
     pending.finish({ answers: params.answers });
   }
 
+  private canStopRuntime(sessionId: string): Promise<boolean> {
+    return canStopSessionRuntime({
+      ctx: this.ctx,
+      sessionId,
+      rootAgent: this.owned.get(sessionId)?.handle.agent,
+      hasBridgeActivity: () =>
+        this.stopping ||
+        this.opening.has(sessionId) ||
+        this.closing.has(sessionId) ||
+        this.commandAborts.has(sessionId) ||
+        [...this.interactions.values()].some(
+          (pending) => pending.request.sessionId === sessionId,
+        ),
+      hasActiveSubagentRuns: () => this.subagentRuns.hasActiveRuns(),
+    });
+  }
+
   private close(id: string): Promise<void> {
     const previous = this.closing.get(id);
     if (previous) return previous;
@@ -964,6 +1004,7 @@ export class BridgeService {
       this.tracked.delete(id);
       this.preapproved.delete(id);
       this.lastUsage.delete(id);
+      this.subagentRuns.clearRoot(id);
     })();
     this.closing.set(id, task);
     void task.finally(() => this.closing.delete(id)).catch(() => undefined);
@@ -978,6 +1019,7 @@ export class BridgeService {
       const results = await Promise.allSettled(
         [...this.owned.keys()].map((id) => this.close(id)),
       );
+      this.subagentRuns.clearAll();
       for (const dispose of this.subscriptions.splice(0)) dispose();
       if (results.some((result) => result.status === "rejected"))
         throw new Error("One or more DSH sessions failed to close");

package/server/provider.ts

@@ -48,6 +48,7 @@ const CAPABILITIES = [
   "prompt.command",
   "prompt.image",
   "prompt.steer",
+  "session.can_stop_runtime",
   "session.configure",
   "session.list",
   "session.persistence",
@@ -57,6 +58,8 @@ const CAPABILITIES = [
 ] as const;
 const PERMISSION_PRESET_SETTING = "permissionPreset";
 const PLAN_MODE_SETTING = "planMode";
+// Leave room for the host's ten-second safety-query deadline and IPC overhead.
+const RUNTIME_SAFETY_TIMEOUT_MS = 5_000;
 
 type DetectVersion = (
   executable: string,
@@ -104,6 +107,11 @@ interface SessionState {
   planMode: boolean;
   pendingInteractions: Map<string, InteractionRequest>;
   lane: Promise<void>;
+  /** Includes admitted input still waiting for its dispatch microtask or lane. */
+  pendingOperations: number;
+  /** Reject a safety snapshot if any input or native activity happened meanwhile. */
+  activityRevision: number;
+  ready: boolean;
   closed: boolean;
 }
 
@@ -216,13 +224,22 @@ function createConnection(
     async send(input) {
       if (closed) throw new Error("Provider connection is closed");
       validateAdmission(input, sessions, capabilities);
+      const operationSession = input.type !== "session.can_stop_runtime" && "sessionId" in input
+        ? sessions.get(input.sessionId)
+        : undefined;
+      if (operationSession) {
+        operationSession.pendingOperations += 1;
+        operationSession.activityRevision += 1;
+      }
       const pending = Promise.resolve().then(async () => {
         if (closed) return;
         await dispatch(input, {
           discoveryBridge, createBridge, sessions, emit, capabilities, detectVersion, launchEnv,
           openingBridges, closeBridge, isClosed: () => closed,
         });
-      }).catch((error) => failInput(input, error, emit));
+      }).catch((error) => failInput(input, error, emit)).finally(() => {
+        if (operationSession) operationSession.pendingOperations -= 1;
+      });
       if (input.type === "session.open") {
         pendingOpens.add(pending);
         void pending.then(() => pendingOpens.delete(pending));
@@ -265,6 +282,7 @@ function listenToSessionBridge(
   return [
     session.bridge.on("session.event", ({ sessionId, event }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       // The prompt path emits its own bubble with the clientMessageId.
       if (event.type === "user/message" && session.dispatch?.kind === "prompt") return;
       if (event.type === "turn/start") {
@@ -309,10 +327,12 @@ function listenToSessionBridge(
     }),
     session.bridge.on("session.stream", ({ sessionId, frame }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       for (const projected of session.projector.projectStream(frame)) emit(projected);
     }),
     session.bridge.on("session.status", ({ sessionId, status }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       if (status === "running") {
         if (session.dispatch) session.dispatch.sawRunning = true;
         return;
@@ -325,6 +345,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("session.usage", ({ sessionId, usage }) => {
       if (!isCurrentSession(sessionId)) return;
+      session.activityRevision += 1;
       emit({
         type: "session.usage",
         sessionId: session.paseoId,
@@ -334,6 +355,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("interaction.request", (interaction) => {
       if (!isCurrentSession(interaction.sessionId)) return;
+      session.activityRevision += 1;
       session.pendingInteractions.set(interaction.requestId, interaction);
       emit({
         type: "session.permission",
@@ -343,6 +365,7 @@ function listenToSessionBridge(
     }),
     session.bridge.on("interaction.closed", ({ requestId, sessionId }) => {
       if (!isCurrentSession(sessionId) || !session.pendingInteractions.delete(requestId)) return;
+      session.activityRevision += 1;
       emit({
         type: "session.permission_resolved",
         sessionId: session.paseoId,
@@ -424,6 +447,9 @@ async function dispatch(input: ProviderInput, state: DispatchState): Promise<voi
     case "session.configure":
       await enqueue(requireSession(state.sessions, input.sessionId), () => configureSession(input, state));
       return;
+    case "session.can_stop_runtime":
+      await canStopRuntime(input, state);
+      return;
     case "session.close":
       await closeSession(input, state);
       return;
@@ -529,6 +555,9 @@ async function openSession(
       planMode: latestPlanMode(opened.events),
       pendingInteractions: new Map(),
       lane: Promise.resolve(),
+      pendingOperations: 0,
+      activityRevision: 0,
+      ready: false,
       closed: false,
     };
     state.sessions.set(input.sessionId, session);
@@ -569,6 +598,8 @@ async function openSession(
     session.projector.seed(session.open.events);
   }
   await warnOnDshVersionMismatch(session, state);
+  if (state.isClosed() || session.closed) return;
+  session.ready = true;
   state.emit({ type: "session.ready", requestId: input.requestId, sessionId: input.sessionId });
 }
 
@@ -825,6 +856,54 @@ async function respondToPermission(
   }
 }
 
+async function canStopRuntime(
+  input: Extract<ProviderInput, { type: "session.can_stop_runtime" }>,
+  state: DispatchState,
+): Promise<void> {
+  const session = requireSession(state.sessions, input.sessionId);
+  if (!isProviderSessionIdle(session)) {
+    state.emit({
+      type: "session.can_stop_runtime",
+      requestId: input.requestId,
+      sessionId: input.sessionId,
+      canStop: false,
+    });
+    return;
+  }
+  const revision = session.activityRevision;
+  const result = await session.bridge.request(
+    "session.can_stop_runtime",
+    { sessionId: session.nativeId },
+    RUNTIME_SAFETY_TIMEOUT_MS,
+  );
+  if (typeof result?.canStop !== "boolean") {
+    throw new Error("Invalid DSH runtime safety response");
+  }
+  const canStop =
+    result.canStop &&
+    state.sessions.get(input.sessionId) === session &&
+    session.activityRevision === revision &&
+    isProviderSessionIdle(session);
+  state.emit({
+    type: "session.can_stop_runtime",
+    requestId: input.requestId,
+    sessionId: input.sessionId,
+    canStop,
+  });
+}
+
+function isProviderSessionIdle(session: SessionState): boolean {
+  return (
+    session.ready &&
+    !session.closed &&
+    session.config.persist &&
+    !session.activeTurnId &&
+    !session.dispatch &&
+    session.pendingInteractions.size === 0 &&
+    session.pendingOperations === 0
+  );
+}
+
 async function closeSession(
   input: Extract<ProviderInput, { type: "session.close" }>,
   state: DispatchState,
@@ -860,6 +939,7 @@ function validateAdmission(
     if (sessions.has(input.sessionId)) throw new Error(`Session already exists: ${input.sessionId}`);
     return;
   }
+  if (input.type === "session.can_stop_runtime") return;
   if ("sessionId" in input && !sessions.has(input.sessionId)) {
     throw new Error(`Unknown session: ${input.sessionId}`);
   }

package/shared/bridge-protocol.ts

@@ -204,6 +204,10 @@ export interface BridgeMethods {
     result: {};
   };
   "session.cancel": { params: { sessionId: string }; result: {} };
+  "session.can_stop_runtime": {
+    params: { sessionId: string };
+    result: { canStop: boolean };
+  };
   "session.close": { params: { sessionId: string }; result: {} };
   "interaction.respond": {
     params: {