feat(vscode): conversation undo with exclusive, broadcast-pushed transcript refresh

apps/vscode/shared/bridge.ts

@@ -37,6 +37,7 @@ export const Methods = {
   ResetSession: "resetSession",
   SetPlanMode: "setPlanMode",
   SteerChat: "steerChat",
+  UndoChat: "undoChat",
   RespondApproval: "respondApproval",
 
   GetKimiSessions: "getKimiSessions",
@@ -96,6 +97,7 @@ export const Events = {
   FileChangesUpdated: "fileChangesUpdated",
   RollbackInput: "rollbackInput",
   LoginUrl: "loginUrl",
+  ConversationHistoryChanged: "conversationHistoryChanged",
 } as const;
 
 const rpcMethods = new Set<string>(Object.values(Methods));
@@ -183,6 +185,12 @@ function validateParams(method: RpcMethod, params: unknown): boolean {
       return hasBoolean(params, "enabled");
     case Methods.SteerChat:
       return isPlainObject(params) && isContent(params["content"]);
+    case Methods.UndoChat:
+      return params === undefined || (
+        isPlainObject(params)
+        && (params["count"] === undefined
+          || (Number.isInteger(params["count"]) && (params["count"] as number) >= 1))
+      );
     case Methods.GetProjectFiles:
       return params === undefined || (
         isPlainObject(params)

apps/vscode/src/handlers/chat.handler.ts

@@ -6,6 +6,7 @@ import type { ApprovalResponse, ContentPart } from "../../shared/legacy-sdk";
 import { getUserMessage } from "../../shared/errors";
 import type { ErrorPhase } from "../../shared/types";
 import { VSCodeSettings } from "../config/vscode-settings";
+import { normalizeEffort } from "../runtime/kimi-runtime";
 import type { SessionRuntime } from "../runtime/session-runtime";
 import { isWorkspacePathContained, relativeWorkspacePath } from "../utils/workspace-path";
 import { parseHostSlashCommand, runHostSlashCommand } from "./slash-command";
@@ -101,11 +102,23 @@ const streamChat: Handler<StreamChatParams, { done: boolean }> = async (params,
   }
 
   try {
+    // Attach no longer overwrites session modes with the configured defaults
+    // (resumed sessions keep their own), so apply the model/effort that the
+    // composer submitted with this prompt before the turn starts.
     const status = await runtime.session.getStatus();
+    let model = status.model;
+    if (params.model && model !== params.model) {
+      await runtime.session.setModel(params.model);
+      model = params.model;
+    }
+    const effort = normalizeEffort(params.effort ?? (params.thinking === true ? "on" : "off"));
+    if (status.thinkingEffort !== effort) {
+      await runtime.session.setThinking(effort);
+    }
     if (params.planMode !== undefined && status.planMode !== params.planMode) {
       await runtime.session.setPlanMode(params.planMode);
     }
-    runtime.announceSessionStart(status.model);
+    runtime.announceSessionStart(model);
   } catch (error) {
     emitCaughtError(ctx, error, "preflight", runtime.id);
     return { done: false };
@@ -133,7 +146,10 @@ const streamChat: Handler<StreamChatParams, { done: boolean }> = async (params,
 
 const abortChat: Handler<void, { aborted: boolean }> = async (_, ctx) => {
   const runtime = ctx.getSession();
-  if (runtime !== undefined) await runtime.cancel();
+  // Do not claim an abort when there is no runtime to cancel — the webview
+  // would otherwise show the task as stopped while the engine keeps running.
+  if (runtime === undefined) return { aborted: false };
+  await runtime.cancel();
   return { aborted: true };
 };
 
@@ -160,6 +176,17 @@ const steerChat: Handler<{ content: string | ContentPart[] }, { ok: boolean }> =
   return { ok: true };
 };
 
+const undoChat: Handler<{ count?: number }, { ok: boolean }> = async (params, ctx) => {
+  const runtime = ctx.getSession();
+  if (runtime === undefined) throw new Error("There is no conversation to undo.");
+  const requested = Number(params?.count);
+  const count = Number.isFinite(requested) && requested >= 1 ? Math.floor(requested) : 1;
+  // The runtime broadcasts ConversationHistoryChanged to every subscribed
+  // view on success; each view rehydrates via LoadKimiSessionHistory.
+  await runtime.undoHistory(count);
+  return { ok: true };
+};
+
 const resetSession: Handler<void, { ok: boolean }> = async (_, ctx) => {
   const runtime = ctx.getSession();
   if (runtime !== undefined) injectedEditorContextSessions.delete(runtime.id);
@@ -175,6 +202,7 @@ export const chatHandlers: Record<string, Handler<any, any>> = {
   [Methods.RespondQuestion]: respondQuestion,
   [Methods.SetPlanMode]: setPlanMode,
   [Methods.SteerChat]: steerChat,
+  [Methods.UndoChat]: undoChat,
   [Methods.ResetSession]: resetSession,
 };
 

apps/vscode/src/runtime/kimi-runtime.ts

@@ -256,21 +256,18 @@ async function applySessionSettings(
   legacyApproval: LegacyApprovalFlags,
 ): Promise<void> {
   const status = await session.getStatus();
-  if (options.model && status.model !== options.model) {
-    await session.setModel(options.model);
-  }
-  // Thinking effort is applied only when the session is created (see
-  // openSession). An existing session keeps its own effort — the global
-  // config value is a default for new sessions, matching CLI/TUI resume
-  // semantics. Effort changes made in the picker reach the active session
-  // through the SaveConfig handler instead.
+  // Model and thinking effort are applied only when the session is created
+  // (see openSession). An existing session keeps its own — the global config
+  // values are defaults for new sessions, matching CLI/TUI resume semantics.
+  // Changes made in the pickers reach the active session through the
+  // SaveConfig handler instead.
   const permission = corePermissionForLegacyApproval(legacyApproval);
   if (status.permission !== permission) {
     await session.setPermission(permission);
   }
 }
 
-function normalizeEffort(effort: string): ThinkingEffort {
+export function normalizeEffort(effort: string): ThinkingEffort {
   return (effort.trim() || "off") as ThinkingEffort;
 }
 

apps/vscode/src/runtime/session-runtime.ts

@@ -22,6 +22,7 @@ import {
   legacyApprovalMetadata,
   type LegacyApprovalFlags,
 } from "./legacy-approval";
+import { replaySessionToWebviewEvents } from "./replay-adapter";
 import { ReverseRpcController } from "./reverse-rpc";
 
 export type RuntimeBroadcast = (event: string, data: unknown, webviewId?: string) => void;
@@ -327,7 +328,11 @@ export class SessionRuntime {
   }
 
   async cancel(): Promise<void> {
-    if (this.closed || !this.hasActiveWork) return;
+    // Always reach the engine, even when the host believes nothing is active.
+    // The host-side bookkeeping can drift from engine truth after an abnormal
+    // error path; session.cancel() is a harmless no-op when the engine is
+    // idle, but it is the only way to recover a turn the host lost track of.
+    if (this.closed) return;
     this.reverseRpc.cancelAll("Turn cancelled");
     const cancellingHostAction = this.hostActionActive;
     const hostActionId = this.activeHostActionId;
@@ -347,6 +352,46 @@ export class SessionRuntime {
     if (failure !== undefined) throw failure.reason;
   }
 
+  /**
+   * Drop the last `count` user turns from the conversation, matching the
+   * CLI's /undo. Runs as one exclusive operation: undo, a single history
+   * reload, and one replay computation. The fresh transcript is then pushed
+   * to every subscribed view in the broadcast payload itself — views apply
+   * it locally and never call back into the engine, so nothing can race
+   * reloads or re-attach a view to the wrong session. A failed reload is
+   * reported distinctly: the undo already landed, so it must not look like
+   * a plain "undo failed".
+   */
+  async undoHistory(count: number): Promise<void> {
+    this.ensureOpen();
+    if (this.isBusy) {
+      throw new Error("Wait for the current response to finish before undoing.");
+    }
+    this.exclusiveActionActive = true;
+    try {
+      await this.session.undoHistory(count);
+      try {
+        await this.session.reloadSession();
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(
+          `Undo applied, but refreshing the conversation failed: ${detail}. Use Reset Kimi to reconcile.`,
+          { cause: error },
+        );
+      }
+      const resumeState = this.session.getResumeState();
+      if (resumeState?.agents["main"] === undefined) {
+        throw new Error("Session history is unavailable.");
+      }
+      const events = replaySessionToWebviewEvents(resumeState, this.id);
+      for (const webviewId of this.webviewIds) {
+        this.broadcast(Events.ConversationHistoryChanged, { sessionId: this.id, events }, webviewId);
+      }
+    } finally {
+      this.exclusiveActionActive = false;
+    }
+  }
+
   /**
    * Stop any in-flight work, wait for its terminal event, and keep new turns
    * out until the supplied operation finishes. Forking uses this so it reads a

apps/vscode/test/bridge-handler.test.ts

@@ -130,6 +130,37 @@ describe("Webview RPC boundary (validates requests before host dispatch)", () =>
     expect(showLogs).not.toHaveBeenCalled();
   });
 
+  it("reports aborted: false when the view has no runtime to cancel", async () => {
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.AbortChat }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: { aborted: false } });
+  });
+
+  it("cancels the view's runtime when aborting a chat", async () => {
+    const cancel = vi.fn(async () => undefined);
+    vi.spyOn(bridge.runtime, "getSessionForView").mockReturnValue({ cancel } as never);
+
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.AbortChat }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", result: { aborted: true } });
+    expect(cancel).toHaveBeenCalledOnce();
+  });
+
+  it("rejects undoChat when the view has no runtime", async () => {
+    const result = await bridge.handle({ id: "rpc-1", method: Methods.UndoChat }, "view-1");
+
+    expect(result).toEqual({ id: "rpc-1", error: "There is no conversation to undo." });
+  });
+
+  it("rejects an invalid undoChat count at the boundary", async () => {
+    const result = await bridge.handle(
+      { id: "rpc-1", method: Methods.UndoChat, params: { count: 0 } },
+      "view-1",
+    );
+
+    expect(result).toEqual({ id: "rpc-1", error: "Invalid bridge params for method: undoChat" });
+  });
+
   it.each(["missingMethod", "toString", "constructor", "__proto__"])(
     "does not dispatch the unknown or prototype method %s",
     async (method) => {