@agentknight/sdk 0.9.35

package/dist/chunks/managed-agent-adapter-HP5VE3AH.js

@@ -0,0 +1,1252 @@
+import {
+  AgentSelectionSchema,
+  assertSelectionSnapshotFits
+} from "./chunk-C7XDS2KG.js";
+import {
+  isResearchSessionId
+} from "./chunk-AHJSR7OY.js";
+import {
+  GroupChatError
+} from "./chunk-ATMWDEPF.js";
+import {
+  AgentModelListingError,
+  AgentSessionRenameError,
+  SessionOperationError,
+  UnsupportedAgentOperationError,
+  captureWorkbenchAccess,
+  validateSessionName
+} from "./chunk-SJHJER3B.js";
+import {
+  InteractionResponseSchema,
+  SessionSummarySchema
+} from "./chunk-ZKAN2FO7.js";
+
+// src/managed-agent-adapter.ts
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+var ManagedSessionIdSchema = z.string().regex(/^managed:(copilot|pi|acp):session:[a-f0-9]{64}$/);
+var StoredSelectionSchema = AgentSelectionSchema.extend({ version: z.literal(1) });
+var LegacySelectionSchema = AgentSelectionSchema.extend({
+  sessionIds: z.array(ManagedSessionIdSchema).max(2e3).refine((ids) => new Set(ids).size === ids.length, "Duplicate managed session selection")
+});
+var DeletedSessionsSchema = z.object({
+  version: z.literal(1),
+  deletedSessionIds: z.array(ManagedSessionIdSchema).refine((ids) => new Set(ids).size === ids.length, "Duplicate deleted managed session"),
+  confirmedDeletedSessionIds: z.array(ManagedSessionIdSchema).optional()
+}).strict().refine((value) => (value.confirmedDeletedSessionIds ?? []).every((id) => value.deletedSessionIds.includes(id)), "Confirmed deletion requires durable deletion intent");
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function sessionId(provider, nativeId) {
+  return `managed:${provider.candidate.id}:session:${digest(nativeId)}`;
+}
+function modelId(provider, nativeId) {
+  return `managed:${provider.candidate.id}:model:${digest(nativeId)}`;
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isMissing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function cancellation(request) {
+  switch (request.kind) {
+    case "permission":
+      return { kind: "permission", decision: "reject" };
+    case "exit_plan":
+      return { kind: "exit_plan", approved: false };
+    case "elicitation":
+      return { kind: "elicitation", action: "cancel", values: {} };
+    case "mcp_oauth":
+      return { kind: "mcp_oauth", action: "cancel" };
+    case "mcp_headers":
+      return { kind: "mcp_headers", action: "none" };
+    case "auto_mode_switch":
+      return { kind: "auto_mode_switch", action: "no" };
+    case "session_limits":
+      return { kind: "session_limits", action: "cancel" };
+    // There is no cancel response in the native user-input contract.
+    case "user_input":
+      return void 0;
+  }
+}
+var ManagedCodingAgentAdapter = class {
+  agentId = "managed";
+  workbench;
+  sdkVersion = "managed-local-agents";
+  #directory;
+  #localOwner;
+  #providers;
+  #initialSelection;
+  #epochs = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Map();
+  #owned = /* @__PURE__ */ new Map();
+  #opening = /* @__PURE__ */ new Map();
+  #peerTurns = /* @__PURE__ */ new Map();
+  #watched = /* @__PURE__ */ new Set();
+  #modelListings = /* @__PURE__ */ new Map();
+  #deleted = /* @__PURE__ */ new Set();
+  #confirmedDeleted = /* @__PURE__ */ new Set();
+  #selection = { agents: [] };
+  #callbacks;
+  #queue = Promise.resolve();
+  #pendingExclusive = 0;
+  #pendingRenames = 0;
+  #upgradeRevision = 0;
+  #started = false;
+  #stopping = false;
+  #groupChatPreference;
+  #peerChatPreference;
+  #groupChatRevision = 0;
+  #pendingGroupOperations = 0;
+  constructor(options) {
+    this.#groupChatPreference = options.groupChatEnabled !== false;
+    this.#peerChatPreference = options.peerChatEnabled !== false;
+    this.#directory = options.dataDirectory;
+    this.#localOwner = SessionSummarySchema.pick({ userId: true, machineId: true }).parse(options.owner);
+    const ids = /* @__PURE__ */ new Set();
+    this.#providers = options.candidates.map((candidate) => {
+      if (!["copilot", "pi", "acp"].includes(candidate.id) || ids.has(candidate.id)) {
+        throw new Error(`Invalid or duplicate managed agent: ${candidate.id}`);
+      }
+      ids.add(candidate.id);
+      return {
+        candidate,
+        available: false,
+        runtime: void 0,
+        shutdown: void 0,
+        error: void 0,
+        nonce: "",
+        sessions: /* @__PURE__ */ new Map(),
+        models: /* @__PURE__ */ new Map(),
+        creating: false
+      };
+    });
+    this.#initialSelection = options.initialSelection === void 0 ? void 0 : this.#validateSelection(options.initialSelection);
+    if (options.candidates.some((candidate) => candidate.id === "copilot")) {
+      this.workbench = {
+        schedules: {
+          isAvailable: () => this.#selectedProviders().some((provider) => provider.candidate.id === "copilot" && provider.runtime?.workbench?.schedules !== void 0),
+          snapshot: (id) => this.#withWorkbench(id, (runtime, native) => {
+            if (runtime.schedules === void 0) throw new SessionOperationError("SCHEDULE_UNSUPPORTED", "Native schedules are unavailable");
+            return runtime.schedules.snapshot(native);
+          }, false),
+          resume: (id, assertAccess) => {
+            const check = this.captureWorkbenchAccess(id);
+            return this.#withWorkbench(id, (runtime, native) => {
+              if (runtime.schedules === void 0) throw new SessionOperationError("SCHEDULE_UNSUPPORTED", "Native schedules are unavailable");
+              return runtime.schedules.resume(native, () => {
+                check();
+                assertAccess?.();
+              });
+            });
+          },
+          create: (id, request, check) => this.#withWorkbench(id, (runtime, native) => {
+            if (runtime.schedules === void 0) throw new SessionOperationError("SCHEDULE_UNSUPPORTED", "Native schedules are unavailable");
+            return runtime.schedules.create(native, request, check);
+          }, false),
+          delete: (id, scheduleId, check) => this.#withWorkbench(id, (runtime, native) => {
+            if (runtime.schedules === void 0) throw new SessionOperationError("SCHEDULE_UNSUPPORTED", "Native schedules are unavailable");
+            return runtime.schedules.delete(native, scheduleId, check);
+          }, false),
+          dismissDraft: (id, draftId, check) => this.#withWorkbench(id, (runtime, native) => {
+            if (runtime.schedules === void 0) throw new SessionOperationError("SCHEDULE_UNSUPPORTED", "Native schedules are unavailable");
+            return runtime.schedules.dismissDraft(native, draftId, check);
+          }, false)
+        },
+        ask: (id, question) => this.#withWorkbench(id, (runtime, native) => runtime.ask(native, question)),
+        commands: (id) => this.#withWorkbench(id, (runtime, native) => runtime.commands(native)),
+        invokeCommand: (id, name, input, operationId) => this.#withWorkbench(id, (runtime, native) => runtime.invokeCommand(native, name, input, operationId)),
+        queue: (id) => this.#withWorkbench(id, (runtime, native) => runtime.queue(native)),
+        mutateQueue: (id, request) => this.#withWorkbench(id, (runtime, native) => runtime.mutateQueue(native, request)),
+        insights: (id) => this.#withWorkbench(id, (runtime, native) => runtime.insights(native)),
+        compact: (id) => this.#withWorkbench(id, (runtime, native) => runtime.compact(native))
+      };
+    }
+  }
+  captureWorkbenchAccess(id) {
+    const route = this.#route(id);
+    const check = captureWorkbenchAccess(route.runtime, route.nativeId);
+    return () => {
+      this.#assertRoute(route);
+      check();
+    };
+  }
+  async renameSession(id, name, assertAccess) {
+    const requested = validateSessionName(name);
+    assertAccess?.();
+    if (!this.isSessionVisible(id)) {
+      throw new AgentSessionRenameError("SESSION_NOT_SHARED", "This session is no longer shared.");
+    }
+    const route = this.#route(id);
+    const check = () => {
+      assertAccess?.();
+      if (!this.#validRoute(route) || route.runtime.isSessionVisible?.(route.nativeId) === false) {
+        throw new AgentSessionRenameError("SESSION_NOT_SHARED", "Session access changed during rename.");
+      }
+      if (route.provider.sessions.get(id)?.renameSupported !== true || route.runtime.renameSession === void 0) {
+        throw new AgentSessionRenameError("AGENT_OPERATION_UNSUPPORTED", "This session does not support native rename.");
+      }
+    };
+    check();
+    const rename2 = route.runtime.renameSession;
+    if (rename2 === void 0) throw new UnsupportedAgentOperationError(route.provider.candidate.id, "session rename");
+    this.#upgradeRevision += 1;
+    this.#pendingRenames += 1;
+    try {
+      const confirmed = await rename2.call(route.runtime, route.nativeId, requested, check);
+      check();
+      if (confirmed !== requested) {
+        throw new AgentSessionRenameError("SESSION_RENAME_FAILED", "The provider did not confirm the requested session name.");
+      }
+      this.#callbacks?.onSessionInventoryChanged(id);
+      return confirmed;
+    } finally {
+      this.#pendingRenames -= 1;
+    }
+  }
+  captureResearchAccess(id) {
+    if (!this.#deleted.has(id)) return { detached: false, assertCurrent: this.captureWorkbenchAccess(id) };
+    const provider = this.#owner(id);
+    const runtime = provider?.runtime;
+    const selection = this.#selection;
+    const assertCurrent = () => {
+      if (!this.#started || this.#stopping || provider?.candidate.id !== "copilot" || runtime === void 0 || provider.runtime !== runtime || !provider.available || this.#selection !== selection || !this.#selection.agents.includes("copilot") || !this.#confirmedDeleted.has(id)) {
+        throw new SessionOperationError("SESSION_NOT_SHARED", "The research source provider is not shared or deletion is unconfirmed");
+      }
+    };
+    assertCurrent();
+    return { detached: true, assertCurrent };
+  }
+  async #withWorkbench(id, operation, owns = true) {
+    const check = this.captureWorkbenchAccess(id);
+    return this.#withSession(id, (route) => {
+      check();
+      const runtime = route.runtime.workbench;
+      if (runtime === void 0) throw new UnsupportedAgentOperationError(route.provider.candidate.id, "workbench");
+      return operation(runtime, route.nativeId);
+    }, owns);
+  }
+  get agentModes() {
+    return this.getSessionCapabilities().agentModes;
+  }
+  get supportsReasoningEffort() {
+    return this.getSessionCapabilities().supportsReasoningEffort;
+  }
+  get supportsSessionListUpdates() {
+    return this.#everySelected((runtime) => runtime.supportsSessionListUpdates === true);
+  }
+  get supportsAssistantPreview() {
+    return this.#everySelected((runtime) => runtime.supportsAssistantPreview === true);
+  }
+  get supportsSessionDelete() {
+    return this.#selectedProviders().some(({ runtime }) => runtime?.supportsSessionDelete === true && runtime.deleteSession !== void 0);
+  }
+  get supportsFileAttachments() {
+    return this.#everySelected((runtime) => runtime.supportsFileAttachments === true);
+  }
+  get groupChatEnabled() {
+    return this.#groupChatPreference && this.#selectedProviders().some((provider) => provider.candidate.id === "copilot" && provider.runtime?.groupChatEnabled === true && provider.runtime.createGroupChat !== void 0);
+  }
+  async setGroupChatEnabled(enabled) {
+    this.#groupChatPreference = enabled;
+    this.#groupChatRevision += 1;
+    this.#upgradeRevision += 1;
+    this.#pendingGroupOperations += 1;
+    try {
+      const updates = this.#providers.filter((provider) => provider.candidate.id === "copilot").map((provider) => provider.runtime?.setGroupChatEnabled?.(enabled));
+      this.#inventoryChanged();
+      await Promise.all(updates);
+    } finally {
+      this.#pendingGroupOperations -= 1;
+      this.#inventoryChanged();
+    }
+  }
+  async createGroupChat(sourceId, peerId, requestId, assertAccess) {
+    if (!this.groupChatEnabled) throw new GroupChatError("GROUP_CHAT_UNAVAILABLE", "Group chat requires an enabled, selected Copilot provider");
+    const source = this.#route(sourceId);
+    const peer = this.#route(peerId);
+    const revision = this.#groupChatRevision;
+    const check = () => {
+      assertAccess?.();
+      if (!this.groupChatEnabled || revision !== this.#groupChatRevision || !this.#validRoute(source) || !this.#validRoute(peer) || source.runtime.isSessionVisible?.(source.nativeId) === false || peer.runtime.isSessionVisible?.(peer.nativeId) === false) {
+        throw new GroupChatError("GROUP_CHAT_UNAVAILABLE", "Group participant access changed; create a new group request");
+      }
+      if (sourceId === peerId || source.provider !== peer.provider || source.runtime !== peer.runtime || source.provider.candidate.id !== "copilot" || [source, peer].some((route) => isResearchSessionId(route.nativeId) || route.provider.sessions.get(route.sessionId)?.groupChat !== void 0)) {
+        throw new GroupChatError("GROUP_CHAT_PARTICIPANT_UNSUPPORTED", "Choose two different ordinary sessions from the same Copilot provider");
+      }
+    };
+    check();
+    const create = source.runtime.createGroupChat;
+    if (create === void 0) throw new GroupChatError("GROUP_CHAT_UNAVAILABLE", "This provider does not support group chat");
+    this.#upgradeRevision += 1;
+    this.#pendingGroupOperations += 1;
+    try {
+      const native = await create.call(source.runtime, source.nativeId, peer.nativeId, requestId, check);
+      check();
+      this.#nativeId(native.sessionId);
+      const id = sessionId(source.provider, native.sessionId);
+      if (native.groupChat === void 0 || this.#deleted.has(id)) {
+        throw new GroupChatError("GROUP_CHAT_UNAVAILABLE", "The group is no longer available");
+      }
+      const summary = this.#summary(id, native, this.#localOwner.userId, this.#localOwner.machineId);
+      assertSelectionSnapshotFits([
+        ...this.#selectedSummaries(this.#selection).filter((session) => session.sessionId !== id),
+        summary
+      ]);
+      source.provider.sessions.set(id, native);
+      this.#owned.set(id, { ...source, sessionId: id, nativeId: native.sessionId, epoch: this.#epoch(id) });
+      this.#inventoryChanged(id);
+      return summary;
+    } finally {
+      this.#pendingGroupOperations -= 1;
+    }
+  }
+  async setPeerChatEnabled(enabled) {
+    this.#peerChatPreference = enabled;
+    this.#upgradeRevision += 1;
+    if (!enabled) {
+      for (const { controller } of this.#peerTurns.values()) {
+        controller.abort(new Error("Peer chat is disabled"));
+      }
+    }
+    this.#pendingGroupOperations += 1;
+    try {
+      const updates = this.#providers.filter((provider) => provider.candidate.id === "copilot").map((provider) => provider.runtime?.setPeerChatEnabled?.(enabled));
+      this.#inventoryChanged();
+      await Promise.all(updates);
+    } finally {
+      this.#pendingGroupOperations -= 1;
+      this.#inventoryChanged();
+    }
+  }
+  async runPeerTurn(id, prompt, options) {
+    if (!this.#peerChatPreference) throw new Error("Peer chat is disabled");
+    options.signal.throwIfAborted();
+    const route = this.#route(id);
+    const run = route.runtime.runPeerTurn;
+    if (route.provider.candidate.id !== "copilot" || run === void 0 || isResearchSessionId(route.nativeId) || route.provider.sessions.get(id)?.groupChat !== void 0) {
+      throw new UnsupportedAgentOperationError(route.provider.candidate.id, "peer session turns");
+    }
+    if (this.#peerTurns.has(id)) throw new Error("A peer turn is already running in this session");
+    const controller = new AbortController();
+    const cancel = () => controller.abort(options.signal.reason);
+    const check = () => {
+      controller.signal.throwIfAborted();
+      if (!this.#peerChatPreference) throw new Error("Peer chat is disabled");
+      this.#assertRoute(route);
+      if (route.runtime.isSessionVisible?.(route.nativeId) === false) throw new Error("Peer session is no longer shared");
+    };
+    check();
+    options.signal.addEventListener("abort", cancel, { once: true });
+    this.#peerTurns.set(id, { route, controller });
+    this.#upgradeRevision += 1;
+    const requestPeer = options.requestPeer;
+    try {
+      const reply = await run.call(route.runtime, route.nativeId, prompt, {
+        signal: controller.signal,
+        ...options.awaitNativeSettlement === true ? { awaitNativeSettlement: true } : {},
+        ...requestPeer === void 0 ? {} : {
+          requestPeer: async (content) => {
+            check();
+            const result = await requestPeer(content);
+            check();
+            return result;
+          }
+        }
+      });
+      check();
+      return reply;
+    } finally {
+      options.signal.removeEventListener("abort", cancel);
+      this.#peerTurns.delete(id);
+    }
+  }
+  getSessionCapabilities(id) {
+    if (id !== void 0) {
+      const route = this.#route(id);
+      return {
+        supportsFileAttachments: route.runtime.supportsFileAttachments === true,
+        ...route.runtime.getSessionCapabilities?.(route.nativeId) ?? {
+          agentModes: route.runtime.agentModes,
+          supportsReasoningEffort: route.runtime.supportsReasoningEffort
+        },
+        agentName: route.provider.candidate.name
+      };
+    }
+    return {
+      agentModes: ["interactive"],
+      supportsReasoningEffort: this.#everySelected((runtime) => runtime.supportsReasoningEffort),
+      supportsFileAttachments: this.supportsFileAttachments
+    };
+  }
+  isSessionVisible(id) {
+    if (!this.#started || this.#stopping || this.#deleted.has(id)) return false;
+    return this.#providers.some((provider) => provider.available && provider.runtime !== void 0 && this.#selection.agents.includes(provider.candidate.id) && provider.sessions.has(id));
+  }
+  setSessionCallbacks(callbacks) {
+    this.#callbacks = callbacks;
+  }
+  start() {
+    if (!this.#started) this.#stopping = false;
+    return this.#exclusive(() => this.#start());
+  }
+  async #start() {
+    if (this.#started) return;
+    if (this.#stopping) throw new Error("Managed agents are stopping");
+    let selection = {
+      agents: this.#providers.filter((provider) => provider.candidate.id === "copilot").map((provider) => provider.candidate.id)
+    };
+    let migrate = false;
+    try {
+      const stored = z.union([StoredSelectionSchema, LegacySelectionSchema]).parse(JSON.parse(await readFile(this.#selectionPath(), "utf8")));
+      selection = this.#validateSelection({ agents: stored.agents });
+      if ("sessionIds" in stored) {
+        for (const id of stored.sessionIds) {
+          const provider = this.#owner(id);
+          if (!provider || !selection.agents.includes(provider.candidate.id)) {
+            throw new Error(`Managed session requires its selected owner: ${id}`);
+          }
+        }
+        migrate = true;
+      }
+    } catch (error) {
+      if (!isMissing(error)) {
+        throw new Error(`Unable to load managed agent selection at ${this.#selectionPath()}: ${message(error)}`, { cause: error });
+      }
+    }
+    let deleted = /* @__PURE__ */ new Set();
+    let confirmedDeleted = /* @__PURE__ */ new Set();
+    try {
+      const stored = DeletedSessionsSchema.parse(JSON.parse(await readFile(this.#deletedPath(), "utf8")));
+      deleted = new Set(stored.deletedSessionIds);
+      confirmedDeleted = new Set(stored.confirmedDeletedSessionIds ?? []);
+    } catch (error) {
+      if (!isMissing(error)) {
+        throw new Error(`Unable to load managed session deletions at ${this.#deletedPath()}: ${message(error)}`, { cause: error });
+      }
+    }
+    if (migrate) await this.#persist(selection);
+    this.#selection = this.#initialSelection ?? selection;
+    this.#deleted = deleted;
+    this.#confirmedDeleted = confirmedDeleted;
+    this.#started = true;
+    await this.#scan();
+  }
+  stop() {
+    this.#stopping = true;
+    for (const peer of this.#peerTurns.values()) peer.controller.abort(new Error("Managed adapter stopped"));
+    return this.#exclusive(async () => {
+      this.#started = false;
+      const results = await Promise.allSettled(this.#providers.map((provider) => this.#retire(provider)));
+      this.#pending.clear();
+      this.#owned.clear();
+      this.#watched.clear();
+      const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+      if (errors.length) throw new AggregateError(errors, "Managed agent shutdown failed");
+    });
+  }
+  async canUpgrade() {
+    const revision = this.#upgradeRevision;
+    if (this.#hasUpgradeWork()) return false;
+    const runtimes = this.#providers.flatMap((provider) => provider.runtime === void 0 ? [] : [provider.runtime]);
+    const ready = await Promise.all(runtimes.map((runtime) => runtime.canUpgrade?.()));
+    return ready.every((value) => value === true) && revision === this.#upgradeRevision && !this.#hasUpgradeWork();
+  }
+  #hasUpgradeWork() {
+    return !this.#started || this.#stopping || this.#pendingExclusive > 0 || this.#pendingRenames > 0 || this.#pendingGroupOperations > 0 || this.#peerTurns.size > 0 || this.#pending.size > 0 || this.#opening.size > 0 || this.#providers.some((provider) => provider.creating || provider.shutdown !== void 0);
+  }
+  listAgents() {
+    return this.#exclusive(async () => {
+      if (!this.#started) await this.#start();
+      else await this.#scan();
+      return this.#providers.map((provider) => {
+        const sessions = [...provider.sessions].map(([id, summary]) => this.#selectableSession(id, summary));
+        return {
+          id: provider.candidate.id,
+          name: provider.candidate.name,
+          available: provider.available && provider.runtime !== void 0,
+          selected: this.#selection.agents.includes(provider.candidate.id),
+          ...provider.error ? { error: provider.error } : {},
+          sessions
+        };
+      });
+    });
+  }
+  async saveSelection(input) {
+    const selection = AgentSelectionSchema.parse(input);
+    return this.#exclusive(async () => {
+      await this.#start();
+      this.#assertStarted();
+      await this.#scan();
+      this.#validateSelection(selection);
+      assertSelectionSnapshotFits(this.#selectedSummaries(selection));
+      await this.#persist(selection);
+      await this.#apply(selection);
+    });
+  }
+  listSessions(userId, machineId) {
+    return this.#exclusive(async () => {
+      this.#assertStarted();
+      await this.#scan();
+      const sessions = this.#selectedSummaries(this.#selection, { userId, machineId });
+      assertSelectionSnapshotFits(sessions);
+      return sessions;
+    });
+  }
+  async listModels(id) {
+    const listing = await this.#exclusive(async () => {
+      this.#assertStarted();
+      const route = id === void 0 ? void 0 : this.#route(id);
+      const providers = route ? [route.provider] : this.#selectedProviders();
+      const snapshot = {
+        route,
+        selection: this.#selection,
+        sources: providers.map((provider) => {
+          const runtime = provider.runtime;
+          if (!runtime) throw new Error("Agent disconnected while listing models");
+          return { provider, runtime, nonce: provider.nonce };
+        })
+      };
+      const key = id ?? "";
+      const pending = this.#modelListings.get(key);
+      if (pending && pending.snapshot.selection === snapshot.selection && pending.snapshot.route?.epoch === route?.epoch && pending.snapshot.sources.length === snapshot.sources.length && pending.snapshot.sources.every((source, index) => source.provider === snapshot.sources[index]?.provider && source.runtime === snapshot.sources[index]?.runtime && source.nonce === snapshot.sources[index]?.nonce)) {
+        return { work: pending.work };
+      }
+      const work = this.#listModels(snapshot).finally(() => {
+        if (this.#modelListings.get(key)?.work === work) this.#modelListings.delete(key);
+      });
+      this.#modelListings.set(key, { snapshot, work });
+      return { work };
+    });
+    return listing.work;
+  }
+  async #listModels(snapshot) {
+    const results = await Promise.all(snapshot.sources.map(async (source) => {
+      try {
+        const nativeModels = await source.runtime.listModels(snapshot.route?.nativeId);
+        const entries = nativeModels.map((model) => {
+          this.#nativeId(model.id);
+          const id = modelId(source.provider, model.id);
+          const { creation: _creation, ...nativeModel } = model;
+          return {
+            nativeId: model.id,
+            model: {
+              ...nativeModel,
+              id,
+              name: (snapshot.route ? model.name : `${source.provider.candidate.name} \xB7 ${model.name}`).slice(0, 260),
+              ...snapshot.route ? {} : {
+                creation: {
+                  agentId: source.provider.candidate.id,
+                  agentName: source.provider.candidate.name,
+                  modelName: model.name,
+                  agentModes: [...source.runtime.agentModes],
+                  reasoningEffortConfigurationSupported: source.runtime.supportsReasoningEffort,
+                  isDefault: model.isDefault
+                }
+              }
+            }
+          };
+        });
+        return { ok: true, source, entries };
+      } catch (error) {
+        return { ok: false, source, error: new Error(
+          `${source.provider.candidate.name} model refresh failed: ${message(error)}`,
+          { cause: error }
+        ) };
+      }
+    }));
+    return this.#exclusive(async () => {
+      this.#assertStarted();
+      if (this.#selection !== snapshot.selection) throw new Error("Agent selection changed while listing models");
+      if (snapshot.route) this.#assertRoute(snapshot.route);
+      for (const { source } of results) {
+        if (source.provider.runtime !== source.runtime || source.provider.nonce !== source.nonce) {
+          throw new Error("Agent disconnected while listing models");
+        }
+      }
+      const models = [];
+      const errors = [];
+      for (const result of results) {
+        if (result.ok) {
+          for (const { nativeId, model } of result.entries) result.source.provider.models.set(model.id, nativeId);
+          models.push(...result.entries.map(({ model }) => model));
+        } else {
+          errors.push(result.error);
+        }
+      }
+      let hasDefault = false;
+      const available = models.map((model) => {
+        const isDefault = model.isDefault && !hasDefault;
+        hasDefault ||= isDefault;
+        return { ...model, isDefault };
+      });
+      if (errors.length) throw new AgentModelListingError(errors, available);
+      return available;
+    });
+  }
+  getSessionConfiguration(id) {
+    return this.#withSession(id, async (route) => this.#configuration(route.provider, await route.runtime.getSessionConfiguration(route.nativeId)), true);
+  }
+  getSessionEnvironment(id) {
+    return this.#withSession(id, (route) => route.runtime.getSessionEnvironment(route.nativeId), true);
+  }
+  getSessionDirectoryMetadata(id) {
+    return this.#withSession(id, (route) => {
+      if (!route.runtime.getSessionDirectoryMetadata) {
+        throw new UnsupportedAgentOperationError(route.provider.candidate.id, "session directory metadata");
+      }
+      return route.runtime.getSessionDirectoryMetadata(route.nativeId);
+    });
+  }
+  getSessionProjectIdentity(id) {
+    return this.#withSession(id, (route) => {
+      if (!route.runtime.getSessionProjectIdentity) {
+        throw new UnsupportedAgentOperationError(route.provider.candidate.id, "session project identity");
+      }
+      return route.runtime.getSessionProjectIdentity(route.nativeId);
+    });
+  }
+  createSession(options) {
+    return this.#exclusive(async () => {
+      this.#assertStarted();
+      await this.#scan();
+      const provider = this.#selectedProviders().find((entry) => entry.models.has(options.modelId));
+      const nativeModelId = provider?.models.get(options.modelId);
+      const runtime = provider?.runtime;
+      if (!provider || !runtime || nativeModelId === void 0) throw new Error("Select an available managed agent model before creating a session");
+      if (!runtime.agentModes.includes(options.agentMode)) throw new UnsupportedAgentOperationError(provider.candidate.id, `creation agent mode ${options.agentMode}`);
+      assertSelectionSnapshotFits(this.#selectedSummaries(this.#selection));
+      provider.creating = true;
+      let native;
+      try {
+        native = await runtime.createSession({ ...options, ...this.#localOwner, modelId: nativeModelId });
+      } finally {
+        provider.creating = false;
+      }
+      this.#nativeId(native.sessionId);
+      const id = sessionId(provider, native.sessionId);
+      if (provider.sessions.has(id) || this.#deleted.has(id)) throw new Error("Agent returned an existing session ID while creating a session");
+      const route = { provider, runtime, sessionId: id, nativeId: native.sessionId, epoch: this.#epoch(id) };
+      this.#owned.set(id, route);
+      try {
+        this.#assertStarted();
+        if (provider.runtime !== runtime) throw new Error("Agent disconnected while creating a session");
+        const summary = this.#summary(id, native, options.userId, options.machineId);
+        assertSelectionSnapshotFits([
+          ...this.#selectedSummaries(this.#selection),
+          this.#summary(id, native, this.#localOwner.userId, this.#localOwner.machineId)
+        ]);
+        provider.sessions.set(id, native);
+        this.#assertRoute(route);
+        this.#inventoryChanged();
+        return summary;
+      } catch (error) {
+        await this.#release(route).catch(async (cleanup) => {
+          await this.#failed(provider, cleanup);
+          throw new AggregateError([error, cleanup], "Unable to publish or cancel the newly created managed session");
+        });
+        throw error;
+      }
+    });
+  }
+  configureSession(id, options) {
+    return this.#withSession(id, async (route) => {
+      const nativeModelId = options.modelId === void 0 ? void 0 : route.provider.models.get(options.modelId);
+      if (options.modelId !== void 0 && nativeModelId === void 0) {
+        throw new Error("Model is unavailable or belongs to another managed agent");
+      }
+      const nativeOptions = { ...options, ...nativeModelId === void 0 ? {} : { modelId: nativeModelId } };
+      return this.#configuration(route.provider, await route.runtime.configureSession(route.nativeId, nativeOptions));
+    }, true);
+  }
+  deleteSession(id) {
+    return this.#exclusive(async () => {
+      const route = this.#route(id);
+      if (!route.runtime.supportsSessionDelete || !route.runtime.deleteSession) {
+        throw new UnsupportedAgentOperationError(route.provider.candidate.id, "session deletion");
+      }
+      const deleted = /* @__PURE__ */ new Set([...this.#deleted, id]);
+      await this.#persistFile(this.#deletedPath(), {
+        version: 1,
+        deletedSessionIds: [...deleted],
+        ...this.#confirmedDeleted.size === 0 ? {} : { confirmedDeletedSessionIds: [...this.#confirmedDeleted] }
+      });
+      this.#deleted = deleted;
+      this.#epochs.set(id, this.#epoch(id) + 1);
+      this.#inventoryChanged();
+      try {
+        this.#assertStarted();
+        if (route.provider.runtime !== route.runtime) throw new Error("Agent disconnected while deleting a session");
+        await route.runtime.deleteSession(route.nativeId);
+        const confirmed = /* @__PURE__ */ new Set([...this.#confirmedDeleted, id]);
+        await this.#persistFile(this.#deletedPath(), {
+          version: 1,
+          deletedSessionIds: [...this.#deleted],
+          confirmedDeletedSessionIds: [...confirmed]
+        });
+        this.#confirmedDeleted = confirmed;
+      } catch (error) {
+        await this.#revoke(id);
+        throw error;
+      }
+      for (const [requestId, pending] of this.#pending) {
+        if (pending.route.sessionId === id) this.#pending.delete(requestId);
+      }
+      this.#owned.delete(id);
+      this.#watched.delete(id);
+      route.provider.sessions.delete(id);
+      this.#inventoryChanged();
+    });
+  }
+  getSessionRemoteStatus(id) {
+    return this.#withSession(id, async (route) => this.#remoteStatus(route, await route.runtime.getSessionRemoteStatus(route.nativeId)));
+  }
+  setSessionRemote(id, enabled) {
+    return this.#withSession(id, async (route) => {
+      const current = await route.runtime.getSessionRemoteStatus(route.nativeId);
+      this.#assertRoute(route);
+      if (current.attachedSessionId !== void 0 && !this.isSessionVisible(sessionId(route.provider, current.attachedSessionId))) {
+        throw new Error("The agent's attached remote session is not selected");
+      }
+      return this.#remoteStatus(route, await route.runtime.setSessionRemote(route.nativeId, enabled));
+    }, enabled);
+  }
+  readSessionTimelinePage(id, options) {
+    return this.#withSession(id, async (route) => {
+      const page = await route.runtime.readSessionTimelinePage(route.nativeId, options);
+      return { ...page, items: page.items.map((item) => this.#item(route, item)) };
+    });
+  }
+  readSessionPlan(id) {
+    return this.#withSession(id, async (route) => {
+      if (route.runtime.readSessionPlan) {
+        try {
+          const item = await route.runtime.readSessionPlan(route.nativeId);
+          return this.#item(route, item);
+        } catch (error) {
+          if (!(error instanceof UnsupportedAgentOperationError)) throw error;
+        }
+      }
+      return {
+        id: `plan:${id}`,
+        kind: "plan-update",
+        revision: 1,
+        turnId: id,
+        timestamp: (/* @__PURE__ */ new Date(0)).toISOString(),
+        sourceEventIds: [`plan:${id}`],
+        actor: "assistant",
+        operation: "deleted",
+        content: "",
+        todos: []
+      };
+    });
+  }
+  watchSession(id, watched) {
+    return this.#withSession(id, async (route) => {
+      await route.runtime.watchSession(route.nativeId, watched);
+      if (watched) this.#watched.add(id);
+      else this.#watched.delete(id);
+    }, watched);
+  }
+  sendPrompt(id, prompt, mode, attachments, persistInteractions, fileAttachments, operationId) {
+    return this.#withSession(id, (route) => {
+      if (fileAttachments?.length && !this.getSessionCapabilities(id).supportsFileAttachments) {
+        throw new UnsupportedAgentOperationError(route.provider.candidate.id, "file attachments");
+      }
+      return route.runtime.sendPrompt(
+        route.nativeId,
+        prompt,
+        mode,
+        attachments,
+        persistInteractions,
+        fileAttachments,
+        ...operationId === void 0 ? [] : [operationId]
+      );
+    }, true);
+  }
+  abortSession(id) {
+    return this.#withSession(id, async (route) => {
+      if (this.#owned.has(id)) await route.runtime.abortSession(route.nativeId);
+    });
+  }
+  respondPermission(id, decision, feedback) {
+    if (decision !== "approve-once" && decision !== "reject") return false;
+    const pending = this.#pending.get(id);
+    if (!pending || pending.kind !== "permission" || !this.#validRoute(pending.route)) return false;
+    const accepted = pending.route.runtime.respondPermission(pending.nativeId, decision, feedback);
+    if (accepted) this.#pending.delete(id);
+    return accepted;
+  }
+  async respondInteraction(id, input) {
+    const response = InteractionResponseSchema.parse(input);
+    const pending = this.#pending.get(id);
+    if (!pending || pending.kind !== "interaction" || !this.#validRoute(pending.route) || pending.request?.kind !== response.kind) return false;
+    if (response.kind === "permission" && pending.request.kind === "permission" && (response.decision === "approve-for-session" && !pending.request.canApproveSession || response.decision === "approve-always" && pending.request.canApproveAlways !== true)) {
+      throw new Error("The agent did not offer this permission approval scope");
+    }
+    const accepted = await pending.route.runtime.respondInteraction(pending.nativeId, response);
+    if (accepted) this.#pending.delete(id);
+    return accepted && this.#validRoute(pending.route);
+  }
+  replayPendingInteractions() {
+    if (!this.#started || this.#stopping) return;
+    for (const provider of this.#selectedProviders()) provider.runtime?.replayPendingInteractions();
+  }
+  #exclusive(operation) {
+    this.#pendingExclusive += 1;
+    this.#upgradeRevision += 1;
+    const result = this.#queue.then(operation);
+    const settled = result.finally(() => {
+      this.#pendingExclusive -= 1;
+    });
+    this.#queue = settled.then(() => void 0, () => void 0);
+    return settled;
+  }
+  #assertStarted() {
+    if (!this.#started || this.#stopping) throw new Error("Managed agents are not running");
+  }
+  #inventoryChanged(id = "selection") {
+    if (this.#started && !this.#stopping) this.#callbacks?.onSessionInventoryChanged(id);
+  }
+  #selectionPath() {
+    return join(this.#directory, "agent-selection.json");
+  }
+  #deletedPath() {
+    return join(this.#directory, "managed-session-deletions.json");
+  }
+  #owner(id) {
+    const match = /^managed:(copilot|pi|acp):session:[a-f0-9]{64}$/.exec(id);
+    return match ? this.#providers.find((provider) => provider.candidate.id === match[1]) : void 0;
+  }
+  #validateSelection(input) {
+    const selection = AgentSelectionSchema.parse(input);
+    for (const id of selection.agents) {
+      if (!this.#providers.some((provider) => provider.candidate.id === id)) throw new Error(`Unknown managed agent: ${id}`);
+    }
+    return selection;
+  }
+  async #persist(selection) {
+    this.#validateSelection(selection);
+    await this.#persistFile(this.#selectionPath(), { version: 1, ...selection });
+  }
+  async #persistFile(path, value) {
+    await mkdir(this.#directory, { recursive: true, mode: 448 });
+    const staging = `${path}.${randomUUID()}.pending`;
+    try {
+      const file = await open(staging, "wx", 384);
+      try {
+        await file.writeFile(`${JSON.stringify(value)}
+`, "utf8");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      await rename(staging, path);
+    } catch (error) {
+      throw new Error(`Unable to persist managed agent state at ${path}: ${message(error)}`, { cause: error });
+    } finally {
+      await rm(staging, { force: true });
+    }
+  }
+  async #apply(selection) {
+    const removed = this.#providers.filter((provider) => this.#selection.agents.includes(provider.candidate.id) && !selection.agents.includes(provider.candidate.id)).flatMap((provider) => [...provider.sessions.keys()]);
+    this.#selection = selection;
+    for (const id of removed) this.#epochs.set(id, this.#epoch(id) + 1);
+    this.#inventoryChanged();
+    await Promise.all(removed.map((id) => this.#revoke(id)));
+  }
+  #selectedProviders() {
+    if (!this.#started || this.#stopping) return [];
+    return this.#providers.filter((provider) => provider.available && provider.runtime && this.#selection.agents.includes(provider.candidate.id));
+  }
+  #selectedSummaries(selection, owner = this.#localOwner) {
+    if (!this.#started || this.#stopping) return [];
+    return this.#providers.filter((provider) => provider.available && provider.runtime && selection.agents.includes(provider.candidate.id)).flatMap((provider) => [...provider.sessions].filter(([id]) => !this.#deleted.has(id)).map(([id, summary]) => this.#summary(id, summary, owner.userId, owner.machineId))).sort((a, b) => Date.parse(b.modifiedAt) - Date.parse(a.modifiedAt) || (a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0));
+  }
+  #everySelected(predicate) {
+    const providers = this.#selectedProviders();
+    return providers.length > 0 && providers.length === this.#selection.agents.length && providers.every((provider) => provider.runtime && predicate(provider.runtime));
+  }
+  async #scan() {
+    this.#assertStarted();
+    const confirmed = new Set(this.#confirmedDeleted);
+    await Promise.all(this.#providers.map(async (provider) => {
+      try {
+        await provider.shutdown;
+        const available = await provider.candidate.detect();
+        if (!available) {
+          provider.available = false;
+          provider.error = "Agent is not installed or configured";
+          await this.#retire(provider);
+          return;
+        }
+        provider.available = true;
+        let runtime = provider.runtime;
+        if (!runtime) {
+          runtime = await provider.candidate.create();
+          provider.runtime = runtime;
+          provider.nonce = randomUUID();
+          if (runtime.agentId !== provider.candidate.id) throw new Error("Managed agent factory returned the wrong provider");
+          runtime.setSessionCallbacks(this.#providerCallbacks(provider, runtime));
+          if (provider.candidate.id === "copilot") await runtime.setGroupChatEnabled?.(this.#groupChatPreference);
+          if (provider.candidate.id === "copilot") await runtime.setPeerChatEnabled?.(this.#peerChatPreference);
+          await runtime.start();
+          if (provider.candidate.id === "copilot") await runtime.setGroupChatEnabled?.(this.#groupChatPreference);
+          if (provider.candidate.id === "copilot") await runtime.setPeerChatEnabled?.(this.#peerChatPreference);
+        }
+        this.#assertStarted();
+        if (provider.runtime !== runtime) throw new Error("Agent disconnected during discovery");
+        const inventory = await runtime.listSessions(this.#localOwner.userId, this.#localOwner.machineId);
+        this.#assertStarted();
+        if (provider.runtime !== runtime) throw new Error("Agent disconnected while listing sessions");
+        const next = /* @__PURE__ */ new Map();
+        const nativeIds = /* @__PURE__ */ new Set();
+        for (const summary of inventory) {
+          this.#nativeId(summary.sessionId);
+          const id = sessionId(provider, summary.sessionId);
+          nativeIds.add(id);
+          if (this.#deleted.has(id)) continue;
+          if (next.has(id)) throw new Error(`Duplicate ${provider.candidate.name} native session identity`);
+          this.#summary(id, summary, this.#localOwner.userId, this.#localOwner.machineId);
+          next.set(id, summary);
+        }
+        for (const id of this.#deleted) {
+          if (this.#owner(id) === provider && !nativeIds.has(id)) confirmed.add(id);
+        }
+        const removed = [...provider.sessions.keys()].filter((id) => !next.has(id));
+        const changed = removed.length > 0 || [...next.keys()].some((id) => !provider.sessions.has(id));
+        provider.sessions = next;
+        provider.error = void 0;
+        for (const id of removed) {
+          this.#epochs.set(id, this.#epoch(id) + 1);
+          await this.#revoke(id);
+        }
+        if (changed && this.#selection.agents.includes(provider.candidate.id)) this.#inventoryChanged();
+      } catch (error) {
+        await this.#failed(provider, error);
+      }
+    }));
+    this.#assertStarted();
+    if (confirmed.size !== this.#confirmedDeleted.size) {
+      await this.#persistFile(this.#deletedPath(), {
+        version: 1,
+        deletedSessionIds: [...this.#deleted],
+        confirmedDeletedSessionIds: [...confirmed]
+      });
+      this.#confirmedDeleted = confirmed;
+      this.#inventoryChanged();
+    }
+  }
+  async #failed(provider, error) {
+    provider.error = `${provider.candidate.name}: ${message(error)}`;
+    provider.available = false;
+    try {
+      await this.#retire(provider);
+    } catch (cleanup) {
+      provider.error += `; shutdown: ${message(cleanup)}`;
+    }
+  }
+  async #retire(provider) {
+    for (const peer of this.#peerTurns.values()) {
+      if (peer.route.provider === provider) peer.controller.abort(new Error("Managed Copilot provider stopped"));
+    }
+    const runtime = provider.runtime;
+    if (!runtime) {
+      await provider.shutdown;
+      return;
+    }
+    provider.runtime = void 0;
+    const visible = provider.sessions.size > 0 && this.#selection.agents.includes(provider.candidate.id);
+    for (const id of provider.sessions.keys()) this.#epochs.set(id, this.#epoch(id) + 1);
+    provider.sessions.clear();
+    provider.models.clear();
+    for (const [id, pending] of this.#pending) {
+      if (pending.route.provider === provider) this.#pending.delete(id);
+    }
+    for (const [id, route] of this.#owned) {
+      if (route.provider === provider) {
+        this.#owned.delete(id);
+        this.#watched.delete(id);
+      }
+    }
+    if (visible) this.#inventoryChanged();
+    const shutdown = runtime.stop();
+    provider.shutdown = shutdown;
+    try {
+      await shutdown;
+    } finally {
+      if (provider.shutdown === shutdown) provider.shutdown = void 0;
+    }
+  }
+  #nativeId(id) {
+    if (typeof id !== "string" || id.length === 0 || id.includes("\0")) throw new Error("Invalid native agent identity");
+  }
+  #selectableSession(id, summary) {
+    return {
+      id,
+      name: summary.summary || summary.sessionId,
+      ...summary.workingDirectory === void 0 ? {} : { workingDirectory: summary.workingDirectory }
+    };
+  }
+  #summary(id, summary, userId, machineId) {
+    const provider = this.#owner(id);
+    if (summary.groupChat !== void 0 && provider?.candidate.id !== "copilot") {
+      throw new GroupChatError("GROUP_CHAT_PARTICIPANT_UNSUPPORTED", "Only Copilot can provide group sessions");
+    }
+    return SessionSummarySchema.parse({
+      ...summary,
+      sessionId: id,
+      userId,
+      machineId,
+      ...summary.groupChat === void 0 || provider === void 0 ? {} : {
+        groupChat: {
+          ...summary.groupChat,
+          participants: summary.groupChat.participants.map((participant) => ({
+            ...participant,
+            sessionId: sessionId(provider, participant.sessionId)
+          }))
+        }
+      },
+      ...summary.summary === void 0 ? {} : { summary: summary.summary.slice(0, 4096) }
+    });
+  }
+  #epoch(id) {
+    return this.#epochs.get(id) ?? 0;
+  }
+  #route(id) {
+    if (!this.isSessionVisible(id)) throw new Error("Managed session is not selected or available");
+    if (this.#hasRevokedOpening(id)) throw new Error("Previous managed session work is still being cancelled");
+    const provider = this.#owner(id);
+    const native = provider?.sessions.get(id);
+    const runtime = provider?.runtime;
+    if (!provider || !native || !runtime) throw new Error("Unknown managed session");
+    return { provider, runtime, sessionId: id, nativeId: native.sessionId, epoch: this.#epoch(id) };
+  }
+  #validRoute(route) {
+    return route.provider.runtime === route.runtime && this.#epoch(route.sessionId) === route.epoch && this.isSessionVisible(route.sessionId);
+  }
+  #assertRoute(route) {
+    if (!this.#validRoute(route)) throw new Error("Managed session selection changed during the operation");
+  }
+  #hasRevokedOpening(id) {
+    return [...this.#opening.get(id) ?? []].some((route) => route.provider.runtime === route.runtime && route.epoch !== this.#epoch(id));
+  }
+  async #withSession(id, operation, owns = false) {
+    const route = this.#route(id);
+    const opening = this.#opening.get(id) ?? /* @__PURE__ */ new Set();
+    if (owns) {
+      this.#upgradeRevision += 1;
+      opening.add(route);
+      this.#opening.set(id, opening);
+    }
+    try {
+      const result = await operation(route);
+      this.#assertRoute(route);
+      if (owns) this.#owned.set(id, route);
+      return result;
+    } finally {
+      if (owns) {
+        try {
+          if (!this.#validRoute(route) && route.provider.runtime === route.runtime) await this.#release(route);
+        } catch (error) {
+          if (route.provider.runtime === route.runtime) {
+            await this.#failed(route.provider, new Error(
+              `Unable to cancel revoked session work: ${message(error)}`,
+              { cause: error }
+            ));
+          }
+          throw error;
+        } finally {
+          opening.delete(route);
+          if (opening.size === 0) this.#opening.delete(id);
+        }
+      }
+    }
+  }
+  #configuration(provider, configuration) {
+    if (configuration.modelId === void 0) return configuration;
+    this.#nativeId(configuration.modelId);
+    const id = modelId(provider, configuration.modelId);
+    provider.models.set(id, configuration.modelId);
+    return { ...configuration, modelId: id };
+  }
+  #remoteStatus(route, status) {
+    if (status.attachedSessionId === void 0) return status;
+    const { attachedSessionId, ...rest } = status;
+    const id = sessionId(route.provider, attachedSessionId);
+    return this.isSessionVisible(id) ? { ...rest, attachedSessionId: id } : { state: "off", steerable: false };
+  }
+  #requestId(route, nativeId, kind) {
+    return `managed:${route.provider.candidate.id}:${kind}:${digest(JSON.stringify([
+      route.nativeId,
+      nativeId,
+      route.provider.nonce,
+      route.epoch
+    ]))}`;
+  }
+  #item(route, item) {
+    const participant = route.provider.sessions.get(route.sessionId)?.groupChat?.participants.find((entry) => "agentId" in item && entry.sessionId === item.agentId);
+    return {
+      ...item,
+      ...participant === void 0 ? {} : { agentId: sessionId(route.provider, participant.sessionId) },
+      ...item.sourceInteractionIds === void 0 ? {} : {
+        sourceInteractionIds: item.sourceInteractionIds.map((id) => this.#requestId(route, id, "interaction"))
+      }
+    };
+  }
+  async #release(route) {
+    this.#owned.delete(route.sessionId);
+    const watched = this.#watched.delete(route.sessionId);
+    if (watched) await route.runtime.watchSession(route.nativeId, false);
+    await route.runtime.abortSession(route.nativeId);
+  }
+  async #revoke(id) {
+    const peer = this.#peerTurns.get(id);
+    if (peer !== void 0) {
+      peer.controller.abort(new Error("Managed session selection changed during the peer turn"));
+      for (const [requestId, pending] of this.#pending) {
+        if (pending.route.sessionId === id) this.#pending.delete(requestId);
+      }
+      this.#owned.delete(id);
+      this.#watched.delete(id);
+      return;
+    }
+    const owned = this.#owned.get(id);
+    const requests = [...this.#pending].filter(([, pending]) => pending.route.sessionId === id);
+    for (const [requestId] of requests) this.#pending.delete(requestId);
+    let restart;
+    try {
+      for (const [, pending] of requests) {
+        if (pending.kind === "permission") {
+          pending.route.runtime.respondPermission(pending.nativeId, "reject");
+        } else if (pending.request) {
+          const response = cancellation(pending.request);
+          if (response) await pending.route.runtime.respondInteraction(pending.nativeId, response);
+          else restart = pending.route.provider;
+        }
+      }
+      if (owned) await this.#release(owned);
+      if (restart) {
+        restart.error = "Agent stopped to cancel a pending native input request; rescan to reconnect";
+        await this.#retire(restart);
+      }
+    } catch (error) {
+      const provider = owned?.provider ?? requests[0]?.[1].route.provider;
+      if (provider) await this.#failed(provider, new Error(`Unable to cancel deselected session: ${message(error)}`, { cause: error }));
+      else throw error;
+    }
+  }
+  #providerCallbacks(provider, runtime) {
+    const nonce = provider.nonce;
+    const failed = async (error) => {
+      if (provider.runtime === runtime && provider.nonce === nonce) await this.#failed(provider, error);
+    };
+    const visible = (nativeId) => {
+      const id = sessionId(provider, nativeId);
+      return provider.runtime === runtime && provider.nonce === nonce && this.isSessionVisible(id) && !this.#hasRevokedOpening(id) ? this.#route(id) : void 0;
+    };
+    const request = (nativeId, requestId, kind, value) => {
+      const route = visible(nativeId);
+      if (!route) return void 0;
+      const id = this.#requestId(route, requestId, kind);
+      this.#pending.set(id, { route, nativeId: requestId, kind, request: value });
+      this.#owned.set(route.sessionId, route);
+      return route;
+    };
+    return {
+      onTimelineReadDiagnostic: (diagnostic) => {
+        if (provider.runtime === runtime && provider.nonce === nonce && this.#selection.agents.includes(provider.candidate.id)) {
+          this.#callbacks?.onTimelineReadDiagnostic?.(diagnostic);
+        }
+      },
+      onConversationItem: (id, item) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onConversationItem(route.sessionId, this.#item(route, item));
+      },
+      onAssistantPreview: (id, item) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onAssistantPreview?.(route.sessionId, this.#item(route, item));
+      },
+      onTransientConversationItem: (id, item) => {
+        const route = visible(id);
+        if (route) {
+          const publish = this.#callbacks?.onTransientConversationItem ?? this.#callbacks?.onConversationItem;
+          publish?.(route.sessionId, this.#item(route, item));
+        }
+      },
+      onConversationActivityStep: (id, delta) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onConversationActivityStep?.(route.sessionId, delta);
+      },
+      onTimelineInvalidated: (id, invalidation) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onTimelineInvalidated?.(route.sessionId, invalidation);
+      },
+      onPermissionRequest: (id, requestId, value) => {
+        const route = request(id, requestId, "permission");
+        if (route) this.#callbacks?.onPermissionRequest(route.sessionId, this.#requestId(route, requestId, "permission"), value);
+        else if (provider.runtime === runtime && provider.nonce === nonce) {
+          try {
+            runtime.respondPermission(requestId, "reject");
+          } catch (error) {
+            void failed(error);
+          }
+        }
+      },
+      onInteractionRequest: (id, requestId, value) => {
+        const route = request(id, requestId, "interaction", value);
+        if (route) this.#callbacks?.onInteractionRequest?.(route.sessionId, this.#requestId(route, requestId, "interaction"), value);
+        else if (provider.runtime === runtime && provider.nonce === nonce) {
+          const response = cancellation(value);
+          if (response) {
+            void runtime.respondInteraction(requestId, response).catch(failed);
+          } else {
+            void failed(new Error("Agent stopped to cancel an unselected native input request"));
+          }
+        }
+      },
+      onInteractionDismissed: (id, requestId) => {
+        const route = visible(id);
+        if (!route) return;
+        const wireId = this.#requestId(route, requestId, "interaction");
+        this.#pending.delete(wireId);
+        this.#callbacks?.onInteractionDismissed?.(route.sessionId, wireId);
+      },
+      onSessionInventoryChanged: (id) => {
+        if (provider.runtime === runtime && provider.nonce === nonce && !provider.creating && this.#started && !this.#stopping && this.#selection.agents.includes(provider.candidate.id) && !this.#deleted.has(sessionId(provider, id))) {
+          this.#inventoryChanged(visible(id)?.sessionId ?? "selection");
+        }
+      },
+      onSessionActivity: (id, state, occurredAt) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onSessionActivity?.(route.sessionId, state, occurredAt);
+      },
+      onSyncError: (id, error) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onSyncError(route.sessionId, error);
+      },
+      onSyncRecovered: (id) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onSyncRecovered?.(route.sessionId);
+      },
+      onProjectMetadataError: (id, error) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onProjectMetadataError?.(route.sessionId, error);
+      },
+      onProjectMetadataRecovered: (id) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onProjectMetadataRecovered?.(route.sessionId);
+      },
+      onImageProjectionFailure: (id, failure) => {
+        const route = visible(id);
+        if (route) this.#callbacks?.onImageProjectionFailure?.(route.sessionId, failure);
+      }
+    };
+  }
+};
+export {
+  ManagedCodingAgentAdapter
+};