feat(core): expose previous agent on selection events

packages/client/src/effect/api/api.ts

@@ -339,7 +339,11 @@ export type Endpoint5_31Output =
           readonly type: "session.agent.selected"
           readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
           readonly location?: Location.Ref | undefined
-          readonly data: { readonly sessionID: Session.ID; readonly agent: Agent.ID }
+          readonly data: {
+            readonly sessionID: Session.ID
+            readonly agent: Agent.ID
+            readonly previous?: Agent.ID | undefined
+          }
         }
       | {
           readonly id: Event.ID

packages/client/src/promise/generated/types.ts

@@ -439,7 +439,7 @@ export type SessionAgentSelected = {
   type: "session.agent.selected"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; agent: string }
+  data: { sessionID: string; agent: string; previous?: string }
 }
 
 export type SessionModelSelected = {

packages/core/src/session.ts

@@ -716,10 +716,11 @@ const layer = Layer.effect(
             .pipe(Effect.ignore, Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid)
       }),
       switchAgent: Effect.fn("Session.switchAgent")(function* (input) {
-        yield* result.get(input.sessionID)
+        const session = yield* result.get(input.sessionID)
         yield* bus.publish(SessionEvent.AgentSelected, {
           sessionID: input.sessionID,
           agent: input.agent,
+          previous: session.agent,
         })
       }),
       switchModel: Effect.fn("Session.switchModel")(function* (input) {

packages/core/test/session-create.test.ts

@@ -648,14 +648,14 @@ describe("Session.create", () => {
   it.effect("switches the selected agent through the durable Session event", () =>
     Effect.gen(function* () {
       const session = yield* Session.Service
-      const created = yield* session.create({ location })
+      const created = yield* session.create({ location, agent: Agent.defaultID })
 
       yield* session.switchAgent({ sessionID: created.id, agent: Agent.ID.make("plan") })
 
       expect(yield* session.get(created.id)).toMatchObject({ agent: "plan" })
       expect(
         Array.from(yield* logEvents(session, created.id, true).pipe(Stream.drop(1), Stream.take(1), Stream.runCollect)),
-      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan" } }])
+      ).toMatchObject([{ type: "session.agent.selected", data: { agent: "plan", previous: "build" } }])
     }),
   )
 

packages/schema/src/session-event.ts

@@ -69,6 +69,7 @@ export const AgentSelected = Event.durable({
   schema: {
     ...Base,
     agent: Agent.ID,
+    previous: Agent.ID.pipe(optional),
   },
 })
 export type AgentSelected = typeof AgentSelected.Type

packages/tui/src/routes/session/index.tsx

@@ -84,7 +84,6 @@ import { usePathFormatter } from "../../context/path-format"
 import { useLocation } from "../../context/location"
 import { PluginSlot } from "../../plugin/render"
 import { usePlugin } from "../../plugin/context"
-import { undoMessage } from "./undo"
 import {
   cacheReuseDrop,
   createSessionRows,
@@ -657,24 +656,19 @@ export function Session() {
       group: "Session",
       slash: { name: "undo" },
       run: () => {
-        const admitted = pendingUsers().at(-1)
         const boundary = session()?.revert?.messageID
-        const message = admitted
-          ? { id: admitted.id, ...admitted.data }
-          : messages().findLast(
-              (message): message is SessionMessageUser =>
-                message.type === "user" && !!message.text.trim() && (!boundary || message.id < boundary),
-            )
+        const message = messages().findLast(
+          (message): message is SessionMessageUser =>
+            message.type === "user" && !!message.text.trim() && (!boundary || message.id < boundary),
+        )
         if (!message) {
           toast.show({ message: "Nothing to undo", variant: "error", duration: 3000 })
           dialog.clear()
           return
         }
-        void undoMessage(client.api, {
-          sessionID: route.sessionID,
-          messageID: message.id,
-          pending: admitted !== undefined,
-        }).catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
+        void client.api.session.revert
+          .stage({ sessionID: route.sessionID, messageID: message.id })
+          .catch((error) => toast.show({ message: errorMessage(error), variant: "error", duration: 5000 }))
         prompt()?.set({
           ...projectedPromptInput(message),
           pasted: [],

packages/tui/src/routes/session/undo.ts

@@ -1,14 +0,0 @@
-import type { OpenCodeClient } from "@opencode-ai/client"
-
-export async function undoMessage(
-  client: OpenCodeClient,
-  input: { readonly sessionID: string; readonly messageID: string; readonly pending: boolean },
-) {
-  const revert = () => client.session.revert.stage(input).then(() => undefined)
-  if (!input.pending) return revert()
-
-  return client.session.pending.cancel({ sessionID: input.sessionID, inputID: input.messageID }).catch((error) => {
-    if (typeof error !== "object" || error === null || !("_tag" in error) || error._tag !== "ConflictError") throw error
-    return revert()
-  })
-}

packages/tui/test/cli/tui/undo.test.ts

@@ -1,48 +0,0 @@
-import { expect, test } from "bun:test"
-import { OpenCode } from "@opencode-ai/client"
-import { undoMessage } from "../../../src/routes/session/undo"
-
-test.each([
-  { name: "projected", pending: false, cancelStatus: 204, expected: ["revert"] },
-  { name: "pending", pending: true, cancelStatus: 204, expected: ["cancel"] },
-  { name: "promoted race", pending: true, cancelStatus: 409, expected: ["cancel", "revert"] },
-])("undo routes $name messages", async ({ pending, cancelStatus, expected }) => {
-  const calls: string[] = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: Object.assign(
-      async (input: URL | RequestInfo, init?: BunFetchRequestInit | RequestInit) => {
-        const request = input instanceof Request ? input : new Request(input, init)
-        const operation = request.method === "DELETE" ? "cancel" : "revert"
-        calls.push(operation)
-        if (operation === "cancel") {
-          if (cancelStatus === 409)
-            return Response.json({ _tag: "ConflictError", message: "Input was promoted" }, { status: 409 })
-          return new Response(null, { status: 204 })
-        }
-        return Response.json({ data: { messageID: "msg_user" } })
-      },
-      { preconnect: fetch.preconnect },
-    ),
-  })
-
-  await undoMessage(client, { sessionID: "ses_test", messageID: "msg_user", pending })
-
-  expect(calls).toEqual([...expected])
-})
-
-test("undo does not reinterpret transport failures as promotion races", async () => {
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: Object.assign(
-      async () => {
-        throw new Error("offline")
-      },
-      { preconnect: fetch.preconnect },
-    ),
-  })
-
-  await expect(
-    undoMessage(client, { sessionID: "ses_test", messageID: "msg_user", pending: true }),
-  ).rejects.toMatchObject({ reason: "Transport" })
-})