mini-coder 0.5.10 → 0.5.12

package/src/ui/agent.ts

@@ -1,10 +1,11 @@
 /**
  * Input parsing, message submission, and streaming agent-event handling for the terminal UI.
  *
- * This module owns the transient streaming render state for the in-progress
- * assistant response. Persistent session and message state remain on
- * {@link AppState}; transient UI concerns are exposed through runtime hooks so
- * `ui.ts` can stay a small orchestrator.
+ * This module builds the controller used by `ui.ts`. Each controller owns its
+ * own transient streaming render state for the in-progress assistant response.
+ * Persistent session and message state remain on {@link AppState}; transient UI
+ * concerns are exposed through runtime hooks so `ui.ts` can stay a small
+ * orchestrator.
  *
  * @module
  */
@@ -22,17 +23,18 @@ import type {
   PendingToolResult,
   StreamingConversationState,
 } from "./conversation.ts";
+import type { UiRenderPriority } from "./runtime.ts";
 
 export { isEmptyUserContent, stripSkillFrontmatter } from "../submit.ts";
 
-/** Streaming assistant content for the current response. */
-let streamingContent: AssistantMessage["content"] = [];
-
-/** Whether a response is currently streaming. */
-let isStreaming = false;
-
-/** Tool results collected during the current streaming turn. */
-let pendingToolResults: PendingToolResult[] = [];
+interface UiAgentRuntimeState {
+  /** Whether a response is currently streaming. */
+  isStreaming: boolean;
+  /** Streaming assistant content for the current response. */
+  content: AssistantMessage["content"];
+  /** Tool results collected during the current streaming turn. */
+  pendingToolResults: PendingToolResult[];
+}
 
 /** Hooks implemented by `ui.ts` to bridge controller logic with runtime UI state. */
 interface UiAgentRuntime {
@@ -40,8 +42,8 @@ interface UiAgentRuntime {
   appendInfoMessage: (text: string, state: AppState) => void;
   /** Dispatch a parsed slash command. */
   handleCommand: (command: string, state: AppState) => boolean;
-  /** Trigger a UI render. */
-  render: () => void;
+  /** Schedule a UI render. */
+  requestRender: (priority?: UiRenderPriority) => void;
   /** Re-enable stick-to-bottom behavior for the conversation log. */
   scrollConversationToBottom: () => void;
   /** Start the active-turn divider animation. */
@@ -54,30 +56,10 @@ interface UiAgentRuntime {
 interface UiAgentController {
   /** Route raw user input through parseInput and dispatch accordingly. */
   handleInput: (raw: string, state: AppState) => void;
-}
-
-/**
- * Reset the transient streaming UI state owned by this module.
- *
- * Used by `resetUiState()` and tests to keep state isolated.
- */
-export function resetUiAgentState(): void {
-  streamingContent = [];
-  isStreaming = false;
-  pendingToolResults = [];
-}
-
-/**
- * Read the current streaming tail state for conversation rendering.
- *
- * @returns The in-progress assistant content and pending tool results.
- */
-export function getStreamingConversationState(): StreamingConversationState {
-  return {
-    isStreaming,
-    content: streamingContent,
-    pendingToolResults,
-  };
+  /** Read the current streaming tail state for conversation rendering. */
+  getStreamingConversationState: () => StreamingConversationState;
+  /** Reset the transient streaming state owned by this controller. */
+  reset: () => void;
 }
 
 /**
@@ -89,6 +71,173 @@ export function getStreamingConversationState(): StreamingConversationState {
 export function createUiAgentController(
   runtime: UiAgentRuntime,
 ): UiAgentController {
+  const streamingState: UiAgentRuntimeState = {
+    isStreaming: false,
+    content: [],
+    pendingToolResults: [],
+  };
+
+  const resetStreamingState = (): boolean => {
+    const changed =
+      streamingState.isStreaming ||
+      streamingState.content.length > 0 ||
+      streamingState.pendingToolResults.length > 0;
+    streamingState.isStreaming = false;
+    streamingState.content = [];
+    streamingState.pendingToolResults = [];
+    return changed;
+  };
+
+  const clearStreamingContent = (): boolean => {
+    if (streamingState.content.length === 0) {
+      return false;
+    }
+    streamingState.content = [];
+    return true;
+  };
+
+  const setStreamingContent = (
+    content: AssistantMessage["content"],
+  ): boolean => {
+    if (streamingState.content === content) {
+      return false;
+    }
+    streamingState.content = content;
+    return true;
+  };
+
+  const upsertPendingToolResult = (
+    event: Extract<AgentEvent, { type: "tool_delta" | "tool_end" }>,
+  ): boolean => {
+    const pending = streamingState.pendingToolResults.find(
+      (toolResult) => toolResult.toolCallId === event.toolCallId,
+    );
+    if (pending) {
+      if (
+        pending.toolName === event.name &&
+        pending.content === event.result.content &&
+        pending.isError === event.result.isError
+      ) {
+        return false;
+      }
+      pending.toolName = event.name;
+      pending.content = event.result.content;
+      pending.isError = event.result.isError;
+      return true;
+    }
+
+    streamingState.pendingToolResults.push({
+      toolCallId: event.toolCallId,
+      toolName: event.name,
+      content: event.result.content,
+      isError: event.result.isError,
+    });
+    return true;
+  };
+
+  const removePendingToolResult = (toolCallId: string): boolean => {
+    const nextPendingToolResults = streamingState.pendingToolResults.filter(
+      (toolResult) => toolResult.toolCallId !== toolCallId,
+    );
+    if (
+      nextPendingToolResults.length === streamingState.pendingToolResults.length
+    ) {
+      return false;
+    }
+    streamingState.pendingToolResults = nextPendingToolResults;
+    return true;
+  };
+
+  const isStreamingContentEvent = (
+    event: AgentEvent,
+  ): event is Extract<
+    AgentEvent,
+    {
+      type:
+        | "text_delta"
+        | "thinking_delta"
+        | "toolcall_start"
+        | "toolcall_delta"
+        | "toolcall_end";
+    }
+  > => {
+    return (
+      event.type === "text_delta" ||
+      event.type === "thinking_delta" ||
+      event.type === "toolcall_start" ||
+      event.type === "toolcall_delta" ||
+      event.type === "toolcall_end"
+    );
+  };
+
+  const isPendingToolProgressEvent = (
+    event: AgentEvent,
+  ): event is Extract<AgentEvent, { type: "tool_delta" | "tool_end" }> => {
+    return event.type === "tool_delta" || event.type === "tool_end";
+  };
+
+  const handleCommittedAgentEvent = (
+    event: Exclude<
+      AgentEvent,
+      | Extract<
+          AgentEvent,
+          {
+            type:
+              | "text_delta"
+              | "thinking_delta"
+              | "toolcall_start"
+              | "toolcall_delta"
+              | "toolcall_end";
+          }
+        >
+      | Extract<AgentEvent, { type: "tool_delta" | "tool_end" }>
+    >,
+  ): void => {
+    switch (event.type) {
+      case "user_message":
+        runtime.scrollConversationToBottom();
+        runtime.requestRender("normal");
+        return;
+      case "assistant_message":
+        if (clearStreamingContent()) {
+          runtime.requestRender("normal");
+        }
+        return;
+      case "tool_result":
+        if (removePendingToolResult(event.message.toolCallId)) {
+          runtime.requestRender("normal");
+        }
+        return;
+      case "done":
+      case "error":
+      case "aborted":
+        if (resetStreamingState()) {
+          runtime.requestRender("normal");
+        }
+        return;
+      case "tool_start":
+        return;
+    }
+  };
+
+  const handleAgentEvent = (event: AgentEvent, _state: AppState): void => {
+    if (isStreamingContentEvent(event)) {
+      if (setStreamingContent(event.content)) {
+        runtime.requestRender("stream");
+      }
+      return;
+    }
+
+    if (isPendingToolProgressEvent(event)) {
+      if (upsertPendingToolResult(event)) {
+        runtime.requestRender("stream");
+      }
+      return;
+    }
+
+    handleCommittedAgentEvent(event);
+  };
+
   const submitMessageAsync = (rawInput: string, state: AppState): void => {
     const resolved = resolveRawInput(rawInput, state);
 
@@ -120,20 +269,19 @@ export function createUiAgentController(
     submitPromise = submitResolvedInput(rawInput, resolved.content, state, {
       onUserMessage: () => {
         runtime.scrollConversationToBottom();
-        runtime.render();
+        runtime.requestRender("normal");
       },
       onTurnStart: () => {
-        isStreaming = true;
-        streamingContent = [];
-        pendingToolResults = [];
+        resetStreamingState();
+        streamingState.isStreaming = true;
         runtime.startDividerAnimation();
-        runtime.render();
+        runtime.requestRender("normal");
       },
       onEvent: (event, currentState) => handleAgentEvent(event, currentState),
       onTurnEnd: () => {
-        resetUiAgentState();
+        resetStreamingState();
         runtime.stopDividerAnimation();
-        runtime.render();
+        runtime.requestRender("normal");
       },
     })
       .then(() => undefined)
@@ -152,70 +300,11 @@ export function createUiAgentController(
     state.activeTurnPromise = submitPromise;
   };
 
-  const handleAgentEvent = (event: AgentEvent, _state: AppState): void => {
-    switch (event.type) {
-      case "text_delta":
-      case "thinking_delta":
-      case "toolcall_start":
-      case "toolcall_delta":
-      case "toolcall_end":
-        streamingContent = event.content;
-        runtime.render();
-        break;
-
-      case "user_message":
-        runtime.scrollConversationToBottom();
-        runtime.render();
-        break;
-
-      case "assistant_message":
-        streamingContent = [];
-        runtime.render();
-        break;
-
-      case "tool_start":
-        break;
-
-      case "tool_delta":
-      case "tool_end": {
-        const pending = pendingToolResults.find(
-          (toolResult) => toolResult.toolCallId === event.toolCallId,
-        );
-        if (pending) {
-          pending.toolName = event.name;
-          pending.content = event.result.content;
-          pending.isError = event.result.isError;
-        } else {
-          pendingToolResults.push({
-            toolCallId: event.toolCallId,
-            toolName: event.name,
-            content: event.result.content,
-            isError: event.result.isError,
-          });
-        }
-        runtime.render();
-        break;
-      }
-
-      case "tool_result":
-        pendingToolResults = pendingToolResults.filter(
-          (toolResult) => toolResult.toolCallId !== event.message.toolCallId,
-        );
-        runtime.render();
-        break;
-
-      case "done":
-      case "error":
-      case "aborted":
-        resetUiAgentState();
-        runtime.render();
-        break;
-    }
-  };
-
-  const handleInput = (raw: string, state: AppState): void => {
-    submitMessageAsync(raw, state);
+  return {
+    handleInput: (raw, state) => {
+      submitMessageAsync(raw, state);
+    },
+    getStreamingConversationState: () => streamingState,
+    reset: resetStreamingState,
   };
-
-  return { handleInput };
 }