wave-code 1.0.4 → 1.0.6

package/dist/contexts/useChat.js

@@ -15,6 +15,66 @@ export const useChat = () => {
     }
     return context;
 };
+/**
+ * Window-concat throttle for pure-delta streaming updates: chunks arriving
+ * within the cooldown window are merged so no delta is lost (a dropped delta
+ * would permanently lose content, unlike the accumulated-payload throttle it
+ * replaces). Leading edge fires immediately; the trailing edge carries only
+ * chunks that arrived within the window. `end` flushes any pending deltas
+ * first, then forwards the end signal right away.
+ */
+function createStreamingWindowThrottle(fn, wait) {
+    let timer = null;
+    let pending = null;
+    const fire = (stage) => {
+        if (pending) {
+            fn({ ...pending, stage });
+            pending = null;
+        }
+    };
+    const throttled = (params) => {
+        if (params.stage === "end") {
+            // Flush any deltas still pending inside the cooldown window first
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            fire("streaming");
+            fn(params);
+            return;
+        }
+        if (pending) {
+            pending.chunk += params.chunk;
+        }
+        else {
+            pending = { messageId: params.messageId, chunk: params.chunk };
+        }
+        if (!timer) {
+            // Leading edge: fire the current delta immediately, then reset pending so
+            // the trailing edge only carries chunks arriving within this window
+            fire("streaming");
+            timer = setTimeout(() => {
+                timer = null;
+                fire("streaming");
+            }, wait);
+        }
+    };
+    throttled.cancel = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        pending = null;
+    };
+    throttled.flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        fire("streaming");
+    };
+    return throttled;
+}
 export const ChatProvider = ({ children, bypassPermissions, permissionMode: initialPermissionMode, pluginDirs, additionalDirectories, tools, allowedTools, disallowedTools, workdir, worktreeSession, originalCwd, version, model, mcpServers, }) => {
     const { restoreSessionId, continueLastSession } = useAppConfig();
     const { stdout } = useStdout();
@@ -26,11 +86,13 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [messages, setMessages] = useState([]);
     const [latestTotalTokens, setLatestTotalTokens] = useState(0);
     const [maxInputTokens, setMaxInputTokens] = useState(200000);
-    // Throttled incremental streaming updaters — 500ms leading+trailing, the same interval
-    // as the pre-incremental throttledSetMessages. `stage === "end"` flushes the final
-    // update immediately so completion results are never delayed.
-    const throttledContentUpdate = useMemo(() => throttle((params) => {
-        const { messageId, accumulated, stage } = params;
+    // Throttled incremental streaming updaters — 500ms window-concat, the same
+    // interval as the pre-incremental throttledSetMessages. Chunks are pure
+    // deltas: within-window chunks are merged so none is dropped, and
+    // `stage === "end"` flushes pending deltas + applies the end signal
+    // immediately so completion results are never delayed.
+    const throttledContentUpdate = useMemo(() => createStreamingWindowThrottle((params) => {
+        const { messageId, chunk, stage } = params;
         setMessages((prev) => prev.map((m) => {
             if (m.id !== messageId)
                 return m;
@@ -38,22 +100,23 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             if (textBlockIndex === -1) {
                 return {
                     ...m,
-                    blocks: [
-                        ...m.blocks,
-                        { type: "text", content: accumulated, stage },
-                    ],
+                    blocks: [...m.blocks, { type: "text", content: chunk, stage }],
                 };
             }
             return {
                 ...m,
                 blocks: m.blocks.map((b, idx) => idx === textBlockIndex && b.type === "text"
-                    ? { ...b, content: accumulated, stage }
+                    ? {
+                        ...b,
+                        content: (b.content || "") + chunk,
+                        stage,
+                    }
                     : b),
             };
         }));
     }, 500), []);
-    const throttledReasoningUpdate = useMemo(() => throttle((params) => {
-        const { messageId, accumulated, stage } = params;
+    const throttledReasoningUpdate = useMemo(() => createStreamingWindowThrottle((params) => {
+        const { messageId, chunk, stage } = params;
         setMessages((prev) => prev.map((m) => {
             if (m.id !== messageId)
                 return m;
@@ -63,14 +126,18 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                     ...m,
                     blocks: [
                         ...m.blocks,
-                        { type: "reasoning", content: accumulated, stage },
+                        { type: "reasoning", content: chunk, stage },
                     ],
                 };
             }
             return {
                 ...m,
                 blocks: m.blocks.map((b, idx) => idx === reasoningBlockIndex && b.type === "reasoning"
-                    ? { ...b, content: accumulated, stage }
+                    ? {
+                        ...b,
+                        content: (b.content || "") + chunk,
+                        stage,
+                    }
                     : b),
             };
         }));
@@ -211,15 +278,11 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 if (isExpandedRef.current)
                     return;
                 throttledContentUpdate(params);
-                if (params.stage === "end")
-                    throttledContentUpdate.flush();
             },
             onAssistantReasoningUpdated: (params) => {
                 if (isExpandedRef.current)
                     return;
                 throttledReasoningUpdate(params);
-                if (params.stage === "end")
-                    throttledReasoningUpdate.flush();
             },
             onToolBlockUpdated: (params) => {
                 if (isExpandedRef.current)
@@ -437,7 +500,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         originalCwd,
         model,
         initialPermissionMode,
-        refreshMessages,
         throttledContentUpdate,
         throttledReasoningUpdate,
         throttledToolBlockUpdate,

package/dist/stdio/agentBridge.d.ts

@@ -71,6 +71,7 @@ export declare class AgentBridge {
     private compact;
     private getBackgroundTaskOutput;
     private stopBackgroundTask;
+    private backgroundCurrentTask;
     private getWorkflowRuns;
     private stopWorkflowRun;
     private setPermissionMode;

package/dist/stdio/agentBridge.js

@@ -140,6 +140,8 @@ export class AgentBridge {
                 return this.getBackgroundTaskOutput(p.taskId, sessionId);
             case "stopBackgroundTask":
                 return this.stopBackgroundTask(p.taskId, sessionId);
+            case "backgroundCurrentTask":
+                return this.backgroundCurrentTask(sessionId);
             case "getWorkflowRuns":
                 return this.getWorkflowRuns(sessionId);
             case "stopWorkflowRun":
@@ -539,6 +541,11 @@ export class AgentBridge {
         const success = entry.agent.stopBackgroundTask(taskId);
         return { success };
     }
+    async backgroundCurrentTask(sessionId) {
+        const entry = this.requireSession(sessionId);
+        await entry.agent.backgroundCurrentTask();
+        return null;
+    }
     async getWorkflowRuns(sessionId) {
         const entry = this.requireSession(sessionId);
         const runs = await entry.agent.getWorkflowRuns();

package/dist/utils/rewindCheckpoints.d.ts

@@ -1,8 +1,8 @@
 import type { Message } from "wave-agent-sdk";
 /**
  * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
- * 都是系统生成、用户不可见的，不能作为回滚点。
+ * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
+ * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
  * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
  */
 export declare function isUserCheckpointMessage(m: Message): boolean;

package/dist/utils/rewindCheckpoints.js

@@ -1,7 +1,7 @@
 /**
  * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
- * 都是系统生成、用户不可见的，不能作为回滚点。
+ * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
+ * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
  * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
  */
 export function isUserCheckpointMessage(m) {
@@ -11,5 +11,7 @@ export function isUserCheckpointMessage(m) {
         return false;
     if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
         return false;
+    if (m.blocks.some((b) => b.type === "bang"))
+        return false;
     return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.0.4"
+    "wave-agent-sdk": "1.0.6"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/contexts/useChat.tsx

@@ -158,6 +158,84 @@ export interface ChatProviderProps extends BaseAppProps {
   children: React.ReactNode;
 }
 
+interface StreamingUpdateParams {
+  messageId: string;
+  chunk: string;
+  stage: "streaming" | "end";
+}
+
+/**
+ * Window-concat throttle for pure-delta streaming updates: chunks arriving
+ * within the cooldown window are merged so no delta is lost (a dropped delta
+ * would permanently lose content, unlike the accumulated-payload throttle it
+ * replaces). Leading edge fires immediately; the trailing edge carries only
+ * chunks that arrived within the window. `end` flushes any pending deltas
+ * first, then forwards the end signal right away.
+ */
+function createStreamingWindowThrottle(
+  fn: (params: StreamingUpdateParams) => void,
+  wait: number,
+): {
+  (params: StreamingUpdateParams): void;
+  cancel: () => void;
+  flush: () => void;
+} {
+  let timer: NodeJS.Timeout | null = null;
+  let pending: { messageId: string; chunk: string } | null = null;
+
+  const fire = (stage: "streaming" | "end") => {
+    if (pending) {
+      fn({ ...pending, stage });
+      pending = null;
+    }
+  };
+
+  const throttled = (params: StreamingUpdateParams) => {
+    if (params.stage === "end") {
+      // Flush any deltas still pending inside the cooldown window first
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      fire("streaming");
+      fn(params);
+      return;
+    }
+    if (pending) {
+      pending.chunk += params.chunk;
+    } else {
+      pending = { messageId: params.messageId, chunk: params.chunk };
+    }
+    if (!timer) {
+      // Leading edge: fire the current delta immediately, then reset pending so
+      // the trailing edge only carries chunks arriving within this window
+      fire("streaming");
+      timer = setTimeout(() => {
+        timer = null;
+        fire("streaming");
+      }, wait);
+    }
+  };
+
+  throttled.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    pending = null;
+  };
+
+  throttled.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    fire("streaming");
+  };
+
+  return throttled;
+}
+
 export const ChatProvider: React.FC<ChatProviderProps> = ({
   children,
   bypassPermissions,
@@ -188,86 +266,77 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [latestTotalTokens, setLatestTotalTokens] = useState(0);
   const [maxInputTokens, setMaxInputTokens] = useState(200000);
 
-  // Throttled incremental streaming updaters — 500ms leading+trailing, the same interval
-  // as the pre-incremental throttledSetMessages. `stage === "end"` flushes the final
-  // update immediately so completion results are never delayed.
+  // Throttled incremental streaming updaters — 500ms window-concat, the same
+  // interval as the pre-incremental throttledSetMessages. Chunks are pure
+  // deltas: within-window chunks are merged so none is dropped, and
+  // `stage === "end"` flushes pending deltas + applies the end signal
+  // immediately so completion results are never delayed.
   const throttledContentUpdate = useMemo(
     () =>
-      throttle(
-        (params: {
-          messageId: string;
-          accumulated: string;
-          stage: "streaming" | "end";
-        }) => {
-          const { messageId, accumulated, stage } = params;
-          setMessages((prev) =>
-            prev.map((m) => {
-              if (m.id !== messageId) return m;
-              const textBlockIndex = m.blocks.findIndex(
-                (b) => b.type === "text",
-              );
-              if (textBlockIndex === -1) {
-                return {
-                  ...m,
-                  blocks: [
-                    ...m.blocks,
-                    { type: "text", content: accumulated, stage },
-                  ],
-                };
-              }
+      createStreamingWindowThrottle((params) => {
+        const { messageId, chunk, stage } = params;
+        setMessages((prev) =>
+          prev.map((m) => {
+            if (m.id !== messageId) return m;
+            const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
+            if (textBlockIndex === -1) {
               return {
                 ...m,
-                blocks: m.blocks.map((b, idx) =>
-                  idx === textBlockIndex && b.type === "text"
-                    ? { ...b, content: accumulated, stage }
-                    : b,
-                ),
+                blocks: [...m.blocks, { type: "text", content: chunk, stage }],
               };
-            }),
-          );
-        },
-        500,
-      ),
+            }
+            return {
+              ...m,
+              blocks: m.blocks.map((b, idx) =>
+                idx === textBlockIndex && b.type === "text"
+                  ? {
+                      ...b,
+                      content: (b.content || "") + chunk,
+                      stage,
+                    }
+                  : b,
+              ),
+            };
+          }),
+        );
+      }, 500),
     [],
   );
 
   const throttledReasoningUpdate = useMemo(
     () =>
-      throttle(
-        (params: {
-          messageId: string;
-          accumulated: string;
-          stage: "streaming" | "end";
-        }) => {
-          const { messageId, accumulated, stage } = params;
-          setMessages((prev) =>
-            prev.map((m) => {
-              if (m.id !== messageId) return m;
-              const reasoningBlockIndex = m.blocks.findIndex(
-                (b) => b.type === "reasoning",
-              );
-              if (reasoningBlockIndex === -1) {
-                return {
-                  ...m,
-                  blocks: [
-                    ...m.blocks,
-                    { type: "reasoning", content: accumulated, stage },
-                  ],
-                };
-              }
+      createStreamingWindowThrottle((params) => {
+        const { messageId, chunk, stage } = params;
+        setMessages((prev) =>
+          prev.map((m) => {
+            if (m.id !== messageId) return m;
+            const reasoningBlockIndex = m.blocks.findIndex(
+              (b) => b.type === "reasoning",
+            );
+            if (reasoningBlockIndex === -1) {
               return {
                 ...m,
-                blocks: m.blocks.map((b, idx) =>
-                  idx === reasoningBlockIndex && b.type === "reasoning"
-                    ? { ...b, content: accumulated, stage }
-                    : b,
-                ),
+                blocks: [
+                  ...m.blocks,
+                  { type: "reasoning", content: chunk, stage },
+                ],
               };
-            }),
-          );
-        },
-        500,
-      ),
+            }
+            return {
+              ...m,
+              blocks: m.blocks.map((b, idx) =>
+                idx === reasoningBlockIndex && b.type === "reasoning"
+                  ? {
+                      ...b,
+                      content: (b.content || "") + chunk,
+                      stage,
+                    }
+                  : b,
+              ),
+            };
+          }),
+        );
+      }, 500),
     [],
   );
 
@@ -477,12 +546,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onAssistantContentUpdated: (params) => {
           if (isExpandedRef.current) return;
           throttledContentUpdate(params);
-          if (params.stage === "end") throttledContentUpdate.flush();
         },
         onAssistantReasoningUpdated: (params) => {
           if (isExpandedRef.current) return;
           throttledReasoningUpdate(params);
-          if (params.stage === "end") throttledReasoningUpdate.flush();
         },
         onToolBlockUpdated: (params) => {
           if (isExpandedRef.current) return;
@@ -730,7 +797,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       originalCwd,
       model,
       initialPermissionMode,
-      refreshMessages,
       throttledContentUpdate,
       throttledReasoningUpdate,
       throttledToolBlockUpdate,

package/src/stdio/agentBridge.ts

@@ -335,6 +335,8 @@ export class AgentBridge {
         return this.getBackgroundTaskOutput(p.taskId as string, sessionId);
       case "stopBackgroundTask":
         return this.stopBackgroundTask(p.taskId as string, sessionId);
+      case "backgroundCurrentTask":
+        return this.backgroundCurrentTask(sessionId);
 
       case "getWorkflowRuns":
         return this.getWorkflowRuns(sessionId);
@@ -905,6 +907,12 @@ export class AgentBridge {
     return { success };
   }
 
+  private async backgroundCurrentTask(sessionId?: string): Promise<null> {
+    const entry = this.requireSession(sessionId);
+    await entry.agent.backgroundCurrentTask();
+    return null;
+  }
+
   private async getWorkflowRuns(
     sessionId?: string,
   ): Promise<{ runs: SerializableWorkflowRun[] }> {

package/src/utils/rewindCheckpoints.ts

@@ -2,8 +2,8 @@ import type { Message } from "wave-agent-sdk";
 
 /**
  * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）与 hook 注入的消息（source: "hook"）
- * 都是系统生成、用户不可见的，不能作为回滚点。
+ * 后台任务通知（task_notification）、hook 注入的消息（source: "hook"）
+ * 与 bang 命令消息都是系统生成、用户不可见的，不能作为回滚点。
  * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
  */
 export function isUserCheckpointMessage(m: Message): boolean {
@@ -11,5 +11,6 @@ export function isUserCheckpointMessage(m: Message): boolean {
   if (m.blocks.some((b) => b.type === "task_notification")) return false;
   if (m.blocks.some((b) => b.type === "text" && b.source === "hook"))
     return false;
+  if (m.blocks.some((b) => b.type === "bang")) return false;
   return true;
 }