feat(core): track previous agent in messages

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

@@ -41,6 +41,7 @@ export type SessionMessageAgentSelected = {
   time: { created: number }
   type: "agent-switched"
   agent: string
+  previous?: string
 }
 
 export type PromptBase64 = string
@@ -2535,6 +2536,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string
@@ -2786,6 +2788,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string
@@ -3037,6 +3040,7 @@ export type SessionImportInput = {
           readonly time: { readonly created: number }
           readonly type: "agent-switched"
           readonly agent: string
+          readonly previous?: string
         }
       | {
           readonly id: string

packages/core/src/session/message-updater.ts

@@ -4,6 +4,7 @@ import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 
 export interface Adapter {
+  readonly getAgent: () => Effect.Effect<SessionMessage.AgentSelected["agent"] | undefined, never, never>
   readonly getModel: () => Effect.Effect<SessionMessage.ModelSelected["model"] | undefined, never, never>
   readonly getCurrentAssistant: () => Effect.Effect<SessionMessage.Assistant | undefined, never, never>
   readonly getAssistant: (
@@ -59,15 +60,19 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.created": () => Effect.void,
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) => {
-        return adapter.appendMessage(
+        return Effect.gen(function* () {
-          SessionMessage.AgentSelected.make({
+          const previous = yield* adapter.getAgent()
-            id: SessionMessage.ID.fromEvent(event.id),
+          yield* adapter.appendMessage(
-            type: "agent-switched",
+            SessionMessage.AgentSelected.make({
-            metadata: event.metadata,
+              id: SessionMessage.ID.fromEvent(event.id),
-            agent: event.data.agent,
+              type: "agent-switched",
-            time: { created: event.created },
+              metadata: event.metadata,
-          }),
+              agent: event.data.agent,
-        )
+              previous,
+              time: { created: event.created },
+            }),
+          )
+        })
       },
       "session.model.selected": (event) => {
         return Effect.gen(function* () {

packages/core/src/session/projector.ts

@@ -6,6 +6,7 @@ import { Database } from "../database/database"
 import { Bus } from "../bus"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Model } from "../model"
+import { Agent } from "../agent"
 import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 import { SessionMessageUpdater } from "./message-updater"
@@ -230,6 +231,17 @@ function run(db: DatabaseService, event: MessageEvent) {
     }
     const appendMessage = (message: SessionMessage.Info) => insertMessage(db, event, message)
     const adapter: SessionMessageUpdater.Adapter = {
+      getAgent() {
+        return db
+          .select({ agent: SessionTable.agent })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, event.data.sessionID))
+          .get()
+          .pipe(
+            Effect.orDie,
+            Effect.map((row) => (row?.agent ? Agent.ID.make(row.agent) : undefined)),
+          )
+      },
       getModel() {
         return db
           .select({ model: SessionTable.model })
@@ -398,12 +410,15 @@ const layer = Layer.effectDiscard(
       db.delete(SessionTable).where(eq(SessionTable.id, event.data.sessionID)).run().pipe(Effect.orDie),
     )
     yield* bus.project(SessionEvent.AgentSelected, (event) =>
-      db
+      Effect.gen(function* () {
-        .update(SessionTable)
+        yield* run(db, event)
-        .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
+        yield* db
-        .where(eq(SessionTable.id, event.data.sessionID))
+          .update(SessionTable)
-        .run()
+          .set({ agent: event.data.agent, time_updated: DateTime.toEpochMillis(event.created) })
-        .pipe(Effect.orDie, Effect.andThen(run(db, event))),
+          .where(eq(SessionTable.id, event.data.sessionID))
+          .run()
+          .pipe(Effect.orDie)
+      }),
     )
     yield* bus.project(SessionEvent.ModelSelected, (event) =>
       Effect.gen(function* () {

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

@@ -358,6 +358,7 @@ describe("SessionProjector", () => {
           directory: "/project",
           title: "test",
           version: "test",
+          agent: build,
           model: previousModel,
         })
         .run()
@@ -366,7 +367,11 @@ describe("SessionProjector", () => {
 
       yield* bus.publish(SessionEvent.AgentSelected, {
         sessionID,
-        agent: build,
+        agent: Agent.ID.make("plan"),
+      })
+      yield* bus.publish(SessionEvent.AgentSelected, {
+        sessionID,
+        agent: Agent.ID.make("general"),
       })
       yield* bus.publish(SessionEvent.ModelSelected, {
         sessionID,
@@ -449,6 +454,7 @@ describe("SessionProjector", () => {
       )
 
       expect(messages.map((message) => message.type)).toEqual([
+        "agent-switched",
         "agent-switched",
         "model-switched",
         "synthetic",
@@ -459,6 +465,10 @@ describe("SessionProjector", () => {
         text: "synthetic context",
         metadata: { source: "projector-test" },
       })
+      expect(messages.filter((message) => message.type === "agent-switched")).toMatchObject([
+        { agent: "plan", previous: "build" },
+        { agent: "general", previous: "plan" },
+      ])
       expect(messages.find((message) => message.type === "model-switched")).toMatchObject({ previous: previousModel })
       expect(messages.find((message) => message.type === "shell")).toMatchObject({
         command: "pwd",
@@ -474,7 +484,7 @@ describe("SessionProjector", () => {
       expect(
         yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie),
       ).toMatchObject({
-        agent: "build",
+        agent: "general",
         model,
         time_updated: DateTime.toEpochMillis(created),
       })

packages/schema/src/session-message.ts

@@ -42,6 +42,7 @@ export const AgentSelected = Schema.Struct({
   ...Base,
   type: Schema.tag("agent-switched"),
   agent: Agent.ID,
+  previous: Agent.ID.pipe(optional),
 }).annotate({ identifier: "Session.Message.AgentSelected" })
 
 export interface ModelSelected extends Schema.Schema.Type<typeof ModelSelected> {}