🤖 fix: use correct model for post-compaction continue messages

Introduced in a31a2e0, the auto-continue message queueing logic was inheriting the compaction model (e.g. haiku) for the follow-up task.

This fix:
1. Preserves the original workspace model as `resumeModel` in compaction metadata
2. Sanitizes the queued continue message options to strip compaction-specific flags
3. Restores the correct model for the follow-up turn

Author: ammar-agent

mobile/src/utils/slashCommandHelpers.test.ts

@@ -56,6 +56,7 @@ describe("buildMobileCompactionPayload", () => {
       model: "anthropic:claude-opus-4-1",
       maxOutputTokens: 800,
       continueMessage: parsed.continueMessage,
+      resumeModel: baseOptions.model,
     });
     expect(payload.sendOptions.model).toBe("anthropic:claude-opus-4-1");
     expect(payload.sendOptions.mode).toBe("compact");

mobile/src/utils/slashCommandHelpers.ts

@@ -57,6 +57,7 @@ export function buildMobileCompactionPayload(
       model: parsed.model,
       maxOutputTokens: parsed.maxOutputTokens,
       continueMessage: parsed.continueMessage,
+      resumeModel: baseOptions.model,
     },
   };
 

src/browser/utils/chatCommands.test.ts

@@ -1,4 +1,5 @@
-import { parseRuntimeString } from "./chatCommands";
+import type { SendMessageOptions } from "@/common/types/ipc";
+import { parseRuntimeString, prepareCompactionMessage } from "./chatCommands";
 
 describe("parseRuntimeString", () => {
   const workspaceName = "test-workspace";
@@ -84,3 +85,57 @@ describe("parseRuntimeString", () => {
     );
   });
 });
+
+describe("prepareCompactionMessage", () => {
+  const createBaseOptions = (): SendMessageOptions => ({
+    model: "anthropic:claude-3-5-sonnet",
+    thinkingLevel: "medium",
+    toolPolicy: [],
+    mode: "exec",
+  });
+
+  const stubLocalStorage = () => {
+    const store: Record<string, string> = {};
+    const storage: Storage = {
+      getItem: (key) => (key in store ? store[key] : null),
+      setItem: (key, value) => {
+        store[key] = String(value);
+      },
+      removeItem: (key) => {
+        delete store[key];
+      },
+      clear: () => {
+        for (const key of Object.keys(store)) {
+          delete store[key];
+        }
+      },
+      key: (index) => Object.keys(store)[index] ?? null,
+      get length() {
+        return Object.keys(store).length;
+      },
+    };
+    globalThis.localStorage = storage;
+  };
+
+  beforeEach(() => {
+    stubLocalStorage();
+  });
+
+  test("embeds resumeModel from base send options", () => {
+    const sendMessageOptions = createBaseOptions();
+    const { metadata } = prepareCompactionMessage({
+      workspaceId: "ws-1",
+      maxOutputTokens: 4096,
+      continueMessage: "Keep building",
+      model: "anthropic:claude-3-5-haiku",
+      sendMessageOptions,
+    });
+
+    expect(metadata.type).toBe("compaction-request");
+    if (metadata.type !== "compaction-request") {
+      throw new Error("Expected compaction metadata");
+    }
+
+    expect(metadata.parsed.resumeModel).toBe(sendMessageOptions.model);
+  });
+});

src/browser/utils/chatCommands.ts

@@ -214,6 +214,7 @@ export function prepareCompactionMessage(options: CompactionOptions): {
     model: effectiveModel,
     maxOutputTokens: options.maxOutputTokens,
     continueMessage: options.continueMessage,
+    resumeModel: options.sendMessageOptions.model,
   };
 
   const metadata: MuxFrontendMetadata = {

src/common/types/message.ts

@@ -10,6 +10,7 @@ export interface CompactionRequestData {
   model?: string; // Custom model override for compaction
   maxOutputTokens?: number;
   continueMessage?: string;
+  resumeModel?: string; // Original workspace model to use after compaction continues
 }
 
 // Frontend-specific metadata stored in muxMetadata field
@@ -103,6 +104,7 @@ export type DisplayedMessage =
         parsed: {
           maxOutputTokens?: number;
           continueMessage?: string;
+          resumeModel?: string;
         };
       };
     }

src/node/services/agentSession.ts

@@ -23,6 +23,7 @@ import { Ok, Err } from "@/common/types/result";
 import { enforceThinkingPolicy } from "@/browser/utils/thinking/policy";
 import { createRuntime } from "@/node/runtime/runtimeFactory";
 import { MessageQueue } from "./messageQueue";
+import { buildContinueMessageOptions } from "./compactionContinueOptions";
 import type { StreamEndEvent, StreamAbortEvent } from "@/common/types/stream";
 import { CompactionHandler } from "./compactionHandler";
 
@@ -336,8 +337,17 @@ export class AgentSession {
     const muxMeta = options?.muxMetadata;
     if (muxMeta?.type === "compaction-request" && muxMeta.parsed.continueMessage && options) {
       // Strip out edit-specific and compaction-specific fields so the queued message is a fresh user message
-      const { muxMetadata, mode, editMessageId, ...continueOptions } = options;
-      this.messageQueue.add(muxMeta.parsed.continueMessage, continueOptions);
+      const { muxMetadata, mode, editMessageId, imageParts, ...rest } = options;
+      const baseContinueOptions: SendMessageOptions = { ...rest };
+      const sanitizedOptions = buildContinueMessageOptions(
+        baseContinueOptions,
+        muxMeta.parsed.resumeModel
+      );
+      const continuePayload =
+        imageParts && imageParts.length > 0
+          ? { ...sanitizedOptions, imageParts }
+          : sanitizedOptions;
+      this.messageQueue.add(muxMeta.parsed.continueMessage, continuePayload);
       this.emitQueuedMessageChanged();
     }
 

src/node/services/compactionContinueOptions.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "bun:test";
+import type { SendMessageOptions } from "@/common/types/ipc";
+import { buildContinueMessageOptions } from "./compactionContinueOptions";
+
+const baseOptions = (): SendMessageOptions => ({
+  model: "anthropic:claude-3-5-sonnet",
+  thinkingLevel: "medium",
+  toolPolicy: [],
+  additionalSystemInstructions: "be helpful",
+  mode: "compact",
+  maxOutputTokens: 2048,
+});
+
+describe("buildContinueMessageOptions", () => {
+  it("uses resumeModel when provided and drops compact overrides", () => {
+    const options = baseOptions();
+    const result = buildContinueMessageOptions(options, "anthropic:claude-3-5-haiku");
+
+    expect(result).not.toBe(options);
+    expect(result.model).toBe("anthropic:claude-3-5-haiku");
+    expect(result.mode).toBeUndefined();
+    expect(result.maxOutputTokens).toBeUndefined();
+    expect(result.thinkingLevel).toBe("medium");
+    expect(result.toolPolicy).toEqual([]);
+    // Ensure original options untouched
+    expect(options.model).toBe("anthropic:claude-3-5-sonnet");
+    expect(options.mode).toBe("compact");
+    expect(options.maxOutputTokens).toBe(2048);
+  });
+
+  it("falls back to compaction model when resumeModel is missing", () => {
+    const options = baseOptions();
+    const result = buildContinueMessageOptions(options);
+
+    expect(result.model).toBe(options.model);
+  });
+});

src/node/services/compactionContinueOptions.ts

@@ -0,0 +1,27 @@
+import type { SendMessageOptions } from "@/common/types/ipc";
+
+/**
+ * Build sanitized SendMessageOptions for auto-continue messages after compaction.
+ *
+ * - Drops compaction-specific overrides (mode="compact", maxOutputTokens)
+ * - Removes frontend metadata (muxMetadata)
+ * - Restores the original workspace model when provided
+ */
+export function buildContinueMessageOptions(
+  options: SendMessageOptions,
+  resumeModel?: string
+): SendMessageOptions {
+  const {
+    muxMetadata: _ignoredMetadata,
+    maxOutputTokens: _ignoredMaxOutputTokens,
+    mode: _ignoredMode,
+    ...rest
+  } = options;
+
+  const nextModel = resumeModel ?? options.model;
+
+  return {
+    ...rest,
+    model: nextModel,
+  };
+}