wave-code 1.0.5 → 1.0.7

package/src/contexts/useChat.tsx

@@ -15,6 +15,7 @@ import type {
   BackgroundTask,
   Task,
   SlashCommand,
+  SubagentConfiguration,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -96,6 +97,8 @@ export interface ChatContextType {
   // Slash Command functionality
   slashCommands: SlashCommand[];
   hasSlashCommand: (commandId: string) => boolean;
+  // Agent definitions (for /agents overlay)
+  agentDefinitions: SubagentConfiguration[];
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
@@ -158,6 +161,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 +269,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),
     [],
   );
 
@@ -350,6 +422,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
 
+  // Agent definitions (for /agents overlay)
+  const [agentDefinitions, setAgentDefinitions] = useState<
+    SubagentConfiguration[]
+  >([]);
+
   // Permission state
   const [permissionMode, setPermissionModeState] = useState<PermissionMode>(
     initialPermissionMode ||
@@ -477,12 +554,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;
@@ -560,7 +635,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
             ),
           );
         },
-        onCompleteBangMessage: (command, exitCode, messageId) => {
+        onCompleteBangMessage: (command, exitCode, messageId, output) => {
           if (isExpandedRef.current) return;
           setMessages((prev) =>
             prev.map((m) =>
@@ -569,7 +644,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                     ...m,
                     blocks: m.blocks.map((b, idx) =>
                       idx === m.blocks.length - 1 && b.type === "bang"
-                        ? { ...b, command, exitCode, stage: "end" }
+                        ? {
+                            ...b,
+                            command,
+                            exitCode,
+                            stage: "end",
+                            ...(output !== undefined ? { output } : {}),
+                          }
                         : b,
                     ),
                   }
@@ -711,6 +792,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         // Get initial commands
         const agentSlashCommands = agent.getSlashCommands?.() || [];
         setSlashCommands(agentSlashCommands);
+
+        // Get initial agent definitions
+        const initialAgentDefinitions =
+          agent.getSubagentConfigurations?.() || [];
+        setAgentDefinitions(initialAgentDefinitions);
       } catch (error) {
         console.error("Failed to initialize AI manager:", error);
       }
@@ -730,7 +816,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       originalCwd,
       model,
       initialPermissionMode,
-      refreshMessages,
       throttledContentUpdate,
       throttledReasoningUpdate,
       throttledToolBlockUpdate,
@@ -752,6 +837,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setMessages([]);
     setMcpServerStatuses([]);
     setSlashCommands([]);
+    setAgentDefinitions([]);
     setSessionId("");
     setIsLoading(false);
     setLatestTotalTokens(0);
@@ -1139,6 +1225,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
+    agentDefinitions,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,

package/src/hooks/useInputManager.ts

@@ -242,6 +242,8 @@ export const useInputManager = (
                 });
               } else if (command === "mcp") {
                 dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
+              } else if (command === "agents") {
+                dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
               } else if (command === "rewind") {
                 dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
               } else if (command === "help") {
@@ -493,6 +495,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
   }, []);
 
+  const setShowAgentsManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: show });
+  }, []);
+
   const setShowRewindManager = useCallback((show: boolean) => {
     dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
   }, []);
@@ -657,6 +663,7 @@ export const useInputManager = (
     historySearchQuery: state.historySearchQuery,
     showBackgroundTaskManager: state.showBackgroundTaskManager,
     showMcpManager: state.showMcpManager,
+    showAgentsManager: state.showAgentsManager,
     showRewindManager: state.showRewindManager,
     showHelp: state.showHelp,
     showStatusCommand: state.showStatusCommand,
@@ -702,6 +709,7 @@ export const useInputManager = (
     // Bash/MCP Manager
     setShowBackgroundTaskManager,
     setShowMcpManager,
+    setShowAgentsManager,
     setShowRewindManager,
     setShowHelp,
     setShowStatusCommand,

package/src/managers/inputHandlers.ts

@@ -367,6 +367,8 @@ export const handleCommandSelect = (
           });
         } else if (command === "mcp") {
           dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
+        } else if (command === "agents") {
+          dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
         } else if (command === "rewind") {
           dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
         } else if (command === "help") {

package/src/managers/inputReducer.ts

@@ -130,6 +130,7 @@ export interface InputState {
   imageIdCounter: number;
   showBackgroundTaskManager: boolean;
   showMcpManager: boolean;
+  showAgentsManager: boolean;
   showRewindManager: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
@@ -167,6 +168,7 @@ export const initialState: InputState = {
   imageIdCounter: 1,
   showBackgroundTaskManager: false,
   showMcpManager: false,
+  showAgentsManager: false,
   showRewindManager: false,
   showHelp: false,
   showStatusCommand: false,
@@ -400,6 +402,7 @@ export type InputAction =
   | { type: "CLEAR_IMAGES" }
   | { type: "SET_SHOW_BACKGROUND_TASK_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MCP_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_AGENTS_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_REWIND_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_HELP"; payload: boolean }
   | { type: "SET_SHOW_STATUS_COMMAND"; payload: boolean }
@@ -589,6 +592,12 @@ export function inputReducer(
         showMcpManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_AGENTS_MANAGER":
+      return {
+        ...state,
+        showAgentsManager: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_SHOW_REWIND_MANAGER":
       return {
         ...state,
@@ -970,6 +979,7 @@ export function inputReducer(
           !(
             state.showBackgroundTaskManager ||
             state.showMcpManager ||
+            state.showAgentsManager ||
             state.showRewindManager ||
             state.showHelp ||
             state.showStatusCommand ||

package/src/reducers/agentsManagerReducer.ts

@@ -0,0 +1,91 @@
+import { Key } from "ink";
+
+export type PendingEffect = { type: "CANCEL" };
+
+export interface AgentsManagerState {
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+  pendingEffect: PendingEffect | null;
+}
+
+export type AgentsManagerAction =
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN"; itemCount: number }
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      itemCount: number;
+    }
+  | { type: "CLEAR_PENDING_EFFECT" };
+
+export function agentsManagerReducer(
+  state: AgentsManagerState,
+  action: AgentsManagerAction,
+): AgentsManagerState {
+  switch (action.type) {
+    case "MOVE_UP":
+      return {
+        ...state,
+        selectedIndex: Math.max(0, state.selectedIndex - 1),
+      };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          Math.max(0, action.itemCount - 1),
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.viewMode };
+    case "HANDLE_KEY": {
+      const { key, itemCount } = action;
+
+      if (key.return) {
+        if (state.viewMode === "list") {
+          return { ...state, viewMode: "detail" };
+        }
+        // Aligned with Claude Code AgentDetail: Enter returns to the list.
+        return { ...state, viewMode: "list" };
+      }
+
+      if (key.escape) {
+        if (state.viewMode === "detail") {
+          return { ...state, viewMode: "list" };
+        }
+        return { ...state, pendingEffect: { type: "CANCEL" } };
+      }
+
+      // Detail view does not respond to arrow keys (aligned with CC
+      // AgentDetail, which only Esc/Enter back to the list).
+      if (state.viewMode === "detail") {
+        return state;
+      }
+
+      if (key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+
+      if (key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(
+            Math.max(0, itemCount - 1),
+            state.selectedIndex + 1,
+          ),
+        };
+      }
+
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
+    default:
+      return state;
+  }
+}

package/src/stdio/agentBridge.ts

@@ -42,6 +42,8 @@ import {
   PluginCore,
   validateWorktreeRemovalPath,
   type SlashCommand,
+  loadUserConfigEnv,
+  type SubagentConfiguration,
 } from "wave-agent-sdk";
 import {
   type JsonRpcError,
@@ -140,6 +142,15 @@ export class AgentBridge {
 
   constructor(options: AgentBridgeOptions) {
     this.emit = options.emit;
+    // Mirror the user-level settings env WAVE_SERVER_URL into process.env
+    // before any agent initializes. getAuthStatus (webviewReady →
+    // pushInitialState) can run before the first agent, and AuthService falls
+    // back to the default URL otherwise — refreshing a custom-domain token
+    // against the wrong host 401s into a logged-out state.
+    const userEnv = loadUserConfigEnv();
+    if (userEnv.WAVE_SERVER_URL) {
+      process.env.WAVE_SERVER_URL = userEnv.WAVE_SERVER_URL;
+    }
   }
 
   // ── Public API ────────────────────────────────────────────────
@@ -166,6 +177,10 @@ export class AgentBridge {
         return this.listPendingPermissions();
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
+      case "getConfiguredModels":
+        return this.getConfiguredModels(sessionId);
+      case "setModel":
+        return this.setModel(p.model as string, sessionId);
 
       // ── Messages ──
       case "sendMessage":
@@ -222,6 +237,8 @@ export class AgentBridge {
       // ── Commands ──
       case "getSlashCommands":
         return this.getSlashCommands(sessionId);
+      case "getSubagentConfigurations":
+        return this.getSubagentConfigurations(sessionId);
 
       // ── File / History (global — no session required) ──
       case "searchFiles":
@@ -335,6 +352,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);
@@ -725,6 +744,27 @@ export class AgentBridge {
     return { sessionId: agent.sessionId };
   }
 
+  private getConfiguredModels(sessionId?: string): {
+    models: string[];
+    currentModel: string | undefined;
+  } {
+    const entry = this.requireSession(sessionId);
+    return {
+      models: entry.agent.getConfiguredModels(),
+      currentModel: entry.agent.getModelConfig().model,
+    };
+  }
+
+  private async setModel(model: string, sessionId?: string): Promise<null> {
+    const entry = this.requireSession(sessionId);
+    entry.agent.setModel(model);
+    // Keep storedConfig in sync: updateConfig recreates the agent from
+    // storedConfig, so without this a later config save would revert the
+    // model chosen here.
+    entry.storedConfig = { ...entry.storedConfig, model };
+    return null;
+  }
+
   // ── Messages ──────────────────────────────────────────────────
 
   private async sendMessage(
@@ -905,6 +945,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[] }> {
@@ -976,6 +1022,13 @@ export class AgentBridge {
     return { commands: entry.agent.getSlashCommands() };
   }
 
+  private getSubagentConfigurations(sessionId?: string): {
+    configurations: SubagentConfiguration[];
+  } {
+    const entry = this.requireSession(sessionId);
+    return { configurations: entry.agent.getSubagentConfigurations() };
+  }
+
   // ── File / History (global) ───────────────────────────────────
 
   private async searchFiles(
@@ -1099,13 +1152,6 @@ export class AgentBridge {
     serverUrl: string;
   }> {
     const authService = AuthService.getInstance();
-    // A stale-but-refreshable token still means "logged in" — the daemon may
-    // have started with an expired access token (hourly expiry) and only
-    // refreshes lazily on the first API call. Without this proactive refresh a
-    // fresh client querying right after daemon start gets a false
-    // isAuthenticated and e.g. the desktop welcome page keeps showing the
-    // login button for an authenticated host. Mirrors the refresh that
-    // createAuthAwareFetch does before every real request.
     await authService.checkAndRefreshTokenIfNeeded();
     return {
       isAuthenticated: authService.isSSOAuthenticated(),
@@ -1416,10 +1462,10 @@ export class AgentBridge {
           ctx.registeredSessionId,
         );
       },
-      onCompleteBangMessage: (command, exitCode, messageId) => {
+      onCompleteBangMessage: (command, exitCode, messageId, output) => {
         this.emit(
           "bangMessageCompleted",
-          { command, exitCode, messageId },
+          { command, exitCode, messageId, output },
           ctx.registeredSessionId,
         );
       },

package/src/stdio/protocol.ts

@@ -75,6 +75,8 @@ export type RequestMethod =
   | "getPromptHistory"
   | "searchPromptHistory"
   | "updateConfig"
+  | "getConfiguredModels"
+  | "setModel"
   // Permissions (daemon attach: re-surface pending approvals after reconnect)
   | "listPendingPermissions"
   // Auth

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;
 }