fix(session): preserve context when compaction model is unavailable

Author: sdeonvacation

packages/opencode/src/server/routes/session.ts

@@ -576,7 +576,6 @@ export const SessionRoutes = lazy(() =>
         const sessionID = c.req.valid("param").sessionID
         const body = c.req.valid("json")
         const session = await Session.get(sessionID)
-        await SessionRevert.cleanup(session)
         const msgs = await Session.messages({ sessionID })
         let currentAgent = await Agent.defaultAgent()
         for (let i = msgs.length - 1; i >= 0; i--) {
@@ -586,6 +585,13 @@ export const SessionRoutes = lazy(() =>
             break
           }
         }
+        await SessionCompaction.resolveModel({
+          model: {
+            providerID: body.providerID,
+            modelID: body.modelID,
+          },
+        })
+        await SessionRevert.cleanup(session)
         await SessionCompaction.create({
           sessionID,
           agent: currentAgent,

packages/opencode/src/session/compaction.ts

@@ -204,6 +204,9 @@ Rules:
   }
 
   export interface Interface {
+    readonly resolveModel: (input: {
+      model: { providerID: ProviderID; modelID: ModelID }
+    }) => Effect.Effect<Provider.Model>
     readonly isOverflow: (input: {
       tokens: MessageV2.Assistant["tokens"]
       model: Provider.Model
@@ -255,6 +258,17 @@ Rules:
         return overflow({ cfg: yield* config.get(), tokens: input.tokens, model: input.model })
       })
 
+      const resolveModel = Effect.fn("SessionCompaction.resolveModel")(function* (input: {
+        model: { providerID: ProviderID; modelID: ModelID }
+      }) {
+        const cfg = yield* config.get()
+        const agent = yield* agents.get("compaction")
+        return agent.model
+          ? yield* provider.getModel(agent.model.providerID, agent.model.modelID)
+          : ((yield* resolveLocal(provider, cfg, "compaction")) ??
+              (yield* provider.getModel(input.model.providerID, input.model.modelID)))
+      })
+
       const estimate = Effect.fn("SessionCompaction.estimate")(function* (input: {
         messages: MessageV2.WithParts[]
         model: Provider.Model
@@ -408,10 +422,7 @@ Rules:
 
         const cfg = yield* config.get()
         const agent = yield* agents.get("compaction")
-        const model = agent.model
-          ? yield* provider.getModel(agent.model.providerID, agent.model.modelID)
-          : ((yield* resolveLocal(provider, cfg, "compaction")) ??
-            (yield* provider.getModel(userMessage.model.providerID, userMessage.model.modelID)))
+        const model = yield* resolveModel({ model: userMessage.model })
         const history = compactionPart && messages.at(-1)?.info.id === input.parentID ? messages.slice(0, -1) : messages
         const prior = completedCompactions(history)
         const hidden = new Set(prior.flatMap((item) => [item.userIndex, item.assistantIndex]))
@@ -610,6 +621,7 @@ Rules:
       })
 
       return Service.of({
+        resolveModel,
         isOverflow,
         prune,
         process: processCompaction,
@@ -636,6 +648,10 @@ Rules:
     return runPromise((svc) => svc.isOverflow(input))
   }
 
+  export async function resolveModel(input: { model: { providerID: ProviderID; modelID: ModelID } }) {
+    return runPromise((svc) => svc.resolveModel(input))
+  }
+
   export async function prune(input: { sessionID: SessionID }): Promise<boolean> {
     return runPromise((svc) => svc.prune(input))
   }

packages/opencode/test/cli/cmd/tui/clear-commands.test.ts

@@ -98,4 +98,49 @@ describe("createClearCommands", () => {
       message: "No model selected. Please select a model first.",
     })
   })
+
+  test("compact command shows failure and does not clear when summarize fails", async () => {
+    const messages = [{ info: { id: "m1", role: "user", cost: 0 } }, { info: { id: "m2", role: "assistant", cost: 3 } }]
+    const show = mock((_opts: unknown) => {})
+    const syncSession = mock(async (_sessionID: string, _opts: { force: boolean }) => {})
+    const api: ClearCommandsDeps["sdk"]["client"]["session"] = {
+      messages: mock(async (_input: { sessionID: string }) => ({ data: messages })),
+      deleteMessage: mock(async (_input: { sessionID: string; messageID: string }) => undefined),
+      clearTodo: mock(async (_input: { sessionID: string }) => undefined),
+      delete: mock(async (_input: { sessionID: string }) => undefined),
+      children: mock(async (_input: { sessionID: string }) => ({ data: [] })),
+      summarize: mock(async () => {
+        throw new Error("model unreachable")
+      }),
+    }
+
+    const deps: ClearCommandsDeps = {
+      sdk: { client: { session: api } },
+      sync: { session: { sync: syncSession } },
+      kv: {
+        get: createGet(0),
+        set<T>(_key: string, _value: T) {},
+      },
+      toast: { show },
+      route: { data: { type: "session", sessionID: "ses_1" } },
+      local: { model: { current: () => ({ providerID: "openai", modelID: "gpt-4" }) } },
+    }
+    const [, compact] = createClearCommands(deps)
+
+    await compact.onSelect!(dialog)
+
+    expect(api.summarize).toHaveBeenCalledWith({
+      sessionID: "ses_1",
+      providerID: "openai",
+      modelID: "gpt-4",
+      auto: false,
+    })
+    expect(api.deleteMessage).not.toHaveBeenCalled()
+    expect(api.clearTodo).not.toHaveBeenCalled()
+    expect(syncSession).not.toHaveBeenCalled()
+    expect(show).toHaveBeenCalledWith({
+      variant: "error",
+      message: "Failed to compact: model unreachable",
+    })
+  })
 })

packages/opencode/test/session/compaction.test.ts

@@ -623,6 +623,63 @@ describe("session.compaction.prune", () => {
 })
 
 describe("session.compaction.process", () => {
+  test("resolveModel falls back to requested model when local hybrid model is unavailable", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const mdl = ProviderTest.model({
+          id: ModelID.make("test-model"),
+          providerID: ProviderID.make("test"),
+          limit: { context: 100_000, output: 32_000 },
+        })
+        const provider = ProviderTest.fake({
+          model: mdl,
+          getModel: Effect.fn("TestProvider.getModel")((providerID, modelID) => {
+            if (providerID === ProviderID.make("local") && modelID === ModelID.make("offline")) {
+              return Effect.die(new Error("local unreachable"))
+            }
+            if (providerID === ProviderID.make("test") && modelID === ModelID.make("test-model")) {
+              return Effect.succeed(mdl)
+            }
+            return Effect.die(new Error(`Unknown test model: ${providerID}/${modelID}`))
+          }),
+        })
+        const rt = runtime(
+          "continue",
+          Plugin.defaultLayer,
+          provider,
+          Layer.mock(Config.Service)({
+            get: () =>
+              Effect.succeed({
+                ...Config.Info.parse({}),
+                hybrid: {
+                  enabled: true,
+                  local_model: { providerID: "local", modelID: "offline" },
+                  log_routing: false,
+                  compression_threshold: 10,
+                  compression_timeout_ms: 5000,
+                },
+              }),
+          }),
+        )
+        try {
+          const resolved = await rt.runPromise(
+            SessionCompaction.Service.use((svc) =>
+              svc.resolveModel({
+                model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test-model") },
+              }),
+            ),
+          )
+          expect(resolved.providerID).toBe(ProviderID.make("test"))
+          expect(resolved.id).toBe(ModelID.make("test-model"))
+        } finally {
+          await rt.dispose()
+        }
+      },
+    })
+  })
+
   test("throws when parent is not a user message", async () => {
     await using tmp = await tmpdir()
     await Instance.provide({

packages/opencode/test/session/revert-compact.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test"
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import fs from "fs/promises"
 import path from "path"
 import { Session } from "../../src/session"
@@ -11,9 +11,14 @@ import { Log } from "../../src/util/log"
 import { Instance } from "../../src/project/instance"
 import { MessageID, PartID } from "../../src/session/schema"
 import { tmpdir } from "../fixture/fixture"
+import { Server } from "../../src/server/server"
 
 Log.init({ print: false })
 
+afterEach(() => {
+  mock.restore()
+})
+
 function user(sessionID: string, agent = "default") {
   return Session.updateMessage({
     id: MessageID.ascending(),
@@ -350,6 +355,60 @@ describe("revert + compact workflow", () => {
     })
   })
 
+  test("preserves revert state when summarize fails before compaction starts", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const session = await Session.create({})
+        const sessionID = session.id
+
+        const u1 = await user(sessionID)
+        await text(sessionID, u1.id, "hello")
+        const a1 = await assistant(sessionID, u1.id, tmp.path)
+        await text(sessionID, a1.id, "hi")
+        const u2 = await user(sessionID)
+        await text(sessionID, u2.id, "second")
+        const a2 = await assistant(sessionID, u2.id, tmp.path)
+        await text(sessionID, a2.id, "later")
+
+        await SessionRevert.revert({
+          sessionID,
+          messageID: u2.id,
+        })
+
+        const app = Server.Default().app
+        const before = await Session.get(sessionID)
+        const msgs = await Session.messages({ sessionID })
+        const fail = spyOn(SessionCompaction, "resolveModel").mockRejectedValue(new Error("model unreachable"))
+        const cleanup = spyOn(SessionRevert, "cleanup")
+
+        const res = await app.request(`/session/${sessionID}/summarize`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({
+            providerID: "openai",
+            modelID: "gpt-4",
+            auto: false,
+          }),
+        })
+
+        const after = await Session.get(sessionID)
+        const next = await Session.messages({ sessionID })
+
+        expect(res.status).toBe(500)
+        expect(fail).toHaveBeenCalledTimes(1)
+        expect(cleanup).not.toHaveBeenCalled()
+        expect(after.revert).toEqual(before.revert)
+        expect(next.map((msg) => msg.info.id)).toEqual(msgs.map((msg) => msg.info.id))
+        expect(next).toHaveLength(4)
+        expect(next.some((msg) => msg.parts.some((part) => part.type === "compaction"))).toBe(false)
+      },
+    })
+  })
+
   test("cleanup with partID removes parts from the revert point onward", async () => {
     await using tmp = await tmpdir({ git: true })
     await Instance.provide({