@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/providers/agent.tsx

@@ -0,0 +1,1075 @@
+import type { AbacusClient, ToolUseResult } from "@codellm/api";
+
+import {
+  AgentMode,
+  AgentStatus,
+  AgentSession,
+  CallbackPermissionProvider,
+  type ConversationSegment,
+  type Diagnostic,
+  type McpManager,
+  type PermissionRequest,
+  type PermissionDecision,
+  type ToolDisplayData,
+  type ParsedToolResult,
+} from "@codellm/agent";
+import { AuthExpiredError, NetworkError } from "@codellm/api";
+import {
+  createContext,
+  memo,
+  useCallback,
+  useEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useTransition,
+} from "react";
+
+import type { AgentArgs } from "../args.js";
+import type { FileAttachment, HistorySegment } from "../lib/types.js";
+
+import { useAgentMode } from "../context/agent-mode.js";
+import { useExtensionFile } from "../context/extension-file.js";
+import { useNetworkActivity } from "../context/network-activity.js";
+import { useNotification } from "../context/notification.js";
+import { useApiClient } from "../providers/api-client.js";
+import { showProgress, hideProgress } from "../terminal/progress.js";
+
+export { AgentMode, AgentStatus };
+
+// Re-export permission decision types for permission-options.tsx compatibility
+export type ToolPermissionDecision = "accept" | "reject" | "background" | "allowAlways";
+
+export interface ToolPermissionResult {
+  decision: ToolPermissionDecision;
+  userMessage?: string;
+}
+
+/** Permission pending in the UI — uses SDK's PermissionRequest directly */
+export interface PendingToolPermission {
+  request: PermissionRequest;
+  resolve: (decision: PermissionDecision) => void;
+}
+
+export interface RetryState {
+  attempt: number;
+  maxAttempts: number;
+  delayMs: number;
+  isNetworkError: boolean;
+}
+
+export interface AgentContextValue {
+  conversationId: string | null;
+  conversationTitle: string | null;
+  segments: HistorySegment[];
+  segmentsLength: number;
+  sendMessage: (options: {
+    message: string;
+    selectedModel?: string;
+    fileAttachments?: FileAttachment[];
+  }) => Promise<void>;
+  stop: () => void;
+  rejectPendingPermission: () => void;
+  agentStatus: AgentStatus;
+  clearSegments: () => void;
+  clearSegmentsOnly: () => void;
+  clearTempSegments: () => void;
+  loadConversation: (id: string) => Promise<void>;
+  addNotification: (
+    message: string,
+    severity?: "info" | "warning" | "error",
+    temp?: boolean,
+  ) => void;
+  mcp: McpManager;
+  addAllowedDirectory: (dirPath: string) => void;
+  pendingToolPermission: PendingToolPermission | null;
+  refreshMcpTools: (skipReload?: boolean, showNotification?: boolean) => Promise<void>;
+  isPendingSegmentUpdate: boolean;
+  queuedMessages: string[];
+  addToQueue: (message: string) => void;
+  removeFirstFromQueue: () => void;
+  clearQueue: () => void;
+  /** First queued message drained when the agent was manually stopped — the composer
+   *  should restore this into the input buffer and then call clearDequeuedOnStop(). */
+  dequeuedOnStop: string | null;
+  clearDequeuedOnStop: () => void;
+  /** @deprecated use agentStatus directly */
+  activeToolOutputs: Record<string, string>;
+  retryState: RetryState | null;
+  networkOnline: boolean;
+}
+
+export const AgentContext = createContext<AgentContextValue | null>(null);
+
+// ---------------------------------------------------------------------------
+// Segment reducer
+// ---------------------------------------------------------------------------
+type SegmentAction =
+  | { type: "INIT_SEND"; userSeg: HistorySegment; spinnySeg: HistorySegment }
+  | { type: "TEXT_DELTA"; segId: string; content: string }
+  | { type: "THINKING_DELTA"; segId: string; content: string; startTime: number }
+  | { type: "THINKING_COMPLETE"; segId: string; endTime: number }
+  | { type: "TOOL_DISPLAY_DATA"; toolCallId: string; data: Partial<ToolDisplayData> }
+  | {
+      type: "TOOL_REQUESTED";
+      toolCallId: string;
+      textSegId: string | null;
+      toolSeg: HistorySegment;
+    }
+  | {
+      type: "TOOL_EXECUTION_COMPLETE";
+      toolCallId: string;
+      rawResult: ToolUseResult;
+      parsedResult?: ParsedToolResult;
+      spinnySeg: HistorySegment;
+    }
+  | { type: "TOOL_USER_MESSAGE"; seg: HistorySegment }
+  | { type: "TEXT_COMPLETED"; segId: string }
+  | { type: "FINALIZE"; textSegId: string | null }
+  | { type: "ADD_NOTIFICATION"; seg: HistorySegment }
+  | { type: "ERROR"; errorSeg: HistorySegment }
+  | { type: "REMOVE_USER_SEG"; userSegId: string }
+  | { type: "CLEAR" }
+  | { type: "LOAD"; segments: HistorySegment[] }
+  | { type: "REMOVE_TEMP" };
+
+function segmentsReducer(prev: HistorySegment[], action: SegmentAction): HistorySegment[] {
+  switch (action.type) {
+    case "INIT_SEND":
+      // Remove temp segments, add user message and spinny placeholder
+      return [...prev.filter((s) => s.temp !== true), action.userSeg, action.spinnySeg];
+
+    case "TEXT_DELTA": {
+      const { segId, content } = action;
+      const withoutSpinny = prev.filter((s) => !s.isSpinny);
+      const existing = withoutSpinny.find((s) => s.id === segId);
+      if (existing) {
+        return withoutSpinny.map((s) =>
+          s.id === segId ? { ...s, segment: ((s.segment as string) || "") + content } : s,
+        );
+      }
+      return [
+        ...withoutSpinny,
+        {
+          id: segId,
+          status: "transient",
+          source: "bot",
+          type: "text",
+          segment: content,
+        } as HistorySegment,
+      ];
+    }
+
+    case "THINKING_DELTA": {
+      const { segId, content, startTime } = action;
+      const existing = prev.find((s) => s.id === segId);
+      if (existing) {
+        return prev.map((s) =>
+          s.id === segId ? { ...s, segment: ((s.segment as string) || "") + content } : s,
+        );
+      }
+      return [
+        ...prev,
+        {
+          id: segId,
+          status: "transient",
+          source: "bot",
+          type: "thinking",
+          isSpinny: true,
+          segment: content,
+          thinkingStartTime: startTime,
+        } as HistorySegment,
+      ];
+    }
+
+    case "THINKING_COMPLETE":
+      return prev.map((s) =>
+        s.id === action.segId
+          ? { ...s, status: "completed", isSpinny: false, thinkingEndTime: action.endTime }
+          : s,
+      );
+
+    case "TOOL_DISPLAY_DATA":
+      return prev.map((s) =>
+        s.id === action.toolCallId
+          ? { ...s, toolDisplayData: { ...s.toolDisplayData, ...action.data } }
+          : s,
+      );
+
+    case "TOOL_REQUESTED": {
+      const { textSegId, toolSeg } = action;
+      let withoutSpinny: HistorySegment[];
+      if (textSegId) {
+        withoutSpinny = prev
+          .filter((s) => !s.isSpinny)
+          .map((s) => (s.id === textSegId ? { ...s, status: "completed" as const } : s));
+      } else {
+        withoutSpinny = prev.filter((s) => !s.isSpinny);
+      }
+      return [...withoutSpinny, toolSeg];
+    }
+
+    case "TOOL_EXECUTION_COMPLETE": {
+      const { toolCallId, rawResult, parsedResult, spinnySeg } = action;
+      const updated = prev.map((s) =>
+        s.id === toolCallId
+          ? {
+              ...s,
+              status: "completed" as const,
+              toolUseResult: rawResult,
+              ...(parsedResult !== undefined && { parsedResult }),
+            }
+          : s,
+      );
+      return [...updated, spinnySeg];
+    }
+
+    case "TOOL_USER_MESSAGE":
+      return [...prev, action.seg];
+
+    case "TEXT_COMPLETED":
+      return prev.map((s) => (s.id === action.segId ? { ...s, status: "completed" as const } : s));
+
+    case "FINALIZE": {
+      // Mark transient text segment as completed (if any), then remove all spinny segments
+      let result = prev;
+      if (action.textSegId) {
+        result = result.map((s) =>
+          s.id === action.textSegId ? { ...s, status: "completed" as const } : s,
+        );
+      }
+      return result.filter((s) => !s.isSpinny);
+    }
+
+    case "ADD_NOTIFICATION": {
+      const seg = action.seg;
+      // Deduplicate: if the last segment is a notification with the same message, flash it instead
+      const last = prev[prev.length - 1];
+      if (
+        last &&
+        last.type === "code_llm_notification" &&
+        last.message === seg.message &&
+        last.severity === seg.severity
+      ) {
+        const updated = [...prev];
+        updated[updated.length - 1] = {
+          ...last,
+          flashKey: (last.flashKey ?? 0) + 1,
+        };
+        return updated;
+      }
+      return [...prev, seg];
+    }
+
+    case "ERROR":
+      return [...prev.filter((s) => !s.isSpinny), action.errorSeg];
+
+    case "REMOVE_USER_SEG":
+      return prev.filter((s) => s.id !== action.userSegId);
+
+    case "CLEAR":
+      return [];
+
+    case "LOAD":
+      return action.segments;
+
+    case "REMOVE_TEMP":
+      if (!prev.some((s) => s.temp === true)) return prev;
+      return prev.filter((s) => s.temp !== true);
+
+    default:
+      return prev;
+  }
+}
+
+interface AgentProviderProps extends React.PropsWithChildren {
+  apiClient: AbacusClient;
+  agentArgs?: AgentArgs;
+}
+
+// ---------------------------------------------------------------------------
+// Bridge: ConversationSegment → HistorySegment (temporary until CLI fully adopts ConversationSegment)
+// ---------------------------------------------------------------------------
+function conversationSegmentToHistory(seg: ConversationSegment): HistorySegment {
+  switch (seg.type) {
+    case "text":
+      return {
+        id: seg.id,
+        status: "completed",
+        source: seg.source,
+        type: "text",
+        segment: seg.content,
+      };
+    case "thinking":
+      return {
+        id: seg.id,
+        status: "completed",
+        source: "bot",
+        type: "thinking",
+        segment: seg.content,
+        isSpinny: seg.isSpinny,
+        ...(seg.title !== undefined && { title: seg.title }),
+      };
+    case "tool_call":
+      return {
+        id: seg.id,
+        status: "completed",
+        source: "bot",
+        type: "code_llm_tool_call",
+        toolUseRequest: seg.toolUseRequest,
+        toolUseResult: seg.toolUseResult ?? {
+          id: seg.toolUseRequest.id,
+          content: " ",
+        },
+        ...(seg.parsedResult !== undefined && { parsedResult: seg.parsedResult }),
+        ...(seg.toolDisplayData !== undefined && { toolDisplayData: seg.toolDisplayData }),
+      };
+    case "notification":
+      return {
+        id: seg.id,
+        status: "completed",
+        source: "bot",
+        type: "code_llm_notification",
+        message: seg.message,
+        severity: seg.severity,
+        ...(seg.actions !== undefined && { actions: seg.actions }),
+      };
+    case "tool_group":
+      // Flatten tool groups — each tool becomes its own segment
+      // The first tool carries the group info
+      return {
+        id: seg.id,
+        status: "completed",
+        source: "bot",
+        type: "text",
+        segment: seg.summary,
+      };
+  }
+}
+
+export const AgentProvider = memo(({ children, apiClient, agentArgs }: AgentProviderProps) => {
+  const [isPendingSegmentUpdate, startSegmentTransition] = useTransition();
+  const { agentMode, setAgentMode } = useAgentMode();
+  const agentModeRef = useRef(agentMode);
+  const { notifyActionRequired, notifyTaskComplete } = useNotification();
+  const { startUpload, startDownload, stopActivity } = useNetworkActivity();
+  const { authManager, setAuthExpired } = useApiClient();
+
+  const { connection, pushServer } = useExtensionFile();
+  const connectionRef = useRef(connection);
+  const pushServerRef = useRef(pushServer);
+  useEffect(() => {
+    connectionRef.current = connection;
+  }, [connection]);
+  useEffect(() => {
+    pushServerRef.current = pushServer;
+  }, [pushServer]);
+
+  const [agentStatus, setAgentStatus] = useState<AgentStatus>(AgentStatus.Idle);
+  const [segments, dispatchSegments] = useReducer(segmentsReducer, []);
+  const displayDataMapRef = useRef<Map<string, ToolDisplayData>>(new Map());
+  const [conversationTitle, setConversationTitle] = useState<string | null>(null);
+  const [pendingToolPermission, setPendingToolPermission] = useState<PendingToolPermission | null>(
+    null,
+  );
+  const [queuedMessages, setQueuedMessages] = useState<string[]>([]);
+  const [dequeuedOnStop, setDequeuedOnStop] = useState<string | null>(null);
+  const [retryState, setRetryState] = useState<RetryState | null>(null);
+  const [networkOnline, setNetworkOnline] = useState(true);
+
+  // activeToolOutputs kept for BashToolOutput compatibility
+  const activeToolOutputs: Record<string, string> = {};
+
+  const conversationIdRef = useRef<string | null>(null);
+
+  const cwd = process.cwd();
+
+  const permissionProvider = useMemo(() => {
+    return new CallbackPermissionProvider(
+      async (req: PermissionRequest): Promise<PermissionDecision> => {
+        const conn = connectionRef.current;
+
+        // For edit tool with VS Code connection: show diff in VS Code, show options in CLI
+        if (conn && pushServerRef.current && req.type === "edit_file") {
+          const toolId = req.tool.id;
+          const displayData = displayDataMapRef.current.get(toolId);
+          const input = req.tool.input as Record<string, unknown>;
+          const filePath = String(input.targetFile ?? req.filePath ?? "");
+          const originalContent = displayData?.originalContent ?? req.originalContent ?? "";
+          const newContent =
+            displayData?.newContent ?? req.newContent ?? String(input.codeEdit ?? "");
+
+          if (filePath && (originalContent || newContent)) {
+            const shown = await conn.showDiff({
+              filePath,
+              originalContent,
+              modifiedContent: newContent,
+              toolId,
+            });
+            if (shown) {
+              const pushServer = pushServerRef.current;
+              const editReq: PermissionRequest = {
+                ...req,
+                diffShownInEditor: true,
+              };
+
+              const cliPromise = new Promise<PermissionDecision>((resolve) => {
+                setPendingToolPermission({
+                  request: editReq,
+                  resolve: (decision) => {
+                    setPendingToolPermission(null);
+                    const isAccept =
+                      decision === "accept" ||
+                      decision === "allowAlways" ||
+                      decision === "background" ||
+                      (typeof decision === "object" && decision.type === "accept_with_message") ||
+                      (typeof decision === "object" && decision.type === "question_answers");
+                    setAgentStatus(isAccept ? AgentStatus.ExecutingTool : AgentStatus.Submitted);
+                    resolve(decision);
+                  },
+                });
+                setAgentStatus(AgentStatus.WaitingForToolPermission);
+                void notifyActionRequired("Abacus.AI is waiting for your input");
+              });
+
+              const pushPromise = pushServer.waitForDecision(toolId).then((d) => {
+                setPendingToolPermission(null);
+                return (d === "allowAlways" ? "allowAlways" : d) as PermissionDecision;
+              });
+
+              const decision = await Promise.race([cliPromise, pushPromise]);
+
+              const simpleDecision =
+                decision === "accept" || decision === "reject" || decision === "allowAlways"
+                  ? decision
+                  : decision === "background"
+                    ? "accept"
+                    : typeof decision === "object" && decision.type === "accept_with_message"
+                      ? "accept"
+                      : typeof decision === "object" && decision.type === "reject_with_message"
+                        ? "reject"
+                        : "accept";
+              conn
+                .notifyDiffDecision({
+                  targetFile: filePath,
+                  decision: simpleDecision === "allowAlways" ? "accept" : simpleDecision,
+                })
+                .catch(() => {});
+
+              return decision;
+            }
+          }
+        }
+
+        // For exit_plan_mode with VS Code connection: open plan in VS Code, wait for decision
+        if (conn && pushServerRef.current && req.type === "exit_plan_mode") {
+          const toolId = req.tool.id;
+          const shown = await conn.showToolView({
+            filePath: req.planFilePath,
+            toolKey: toolId,
+          });
+          if (shown) {
+            const decision = await pushServerRef.current.waitForDecision(toolId);
+            return decision === "allowAlways" ? "allowAlways" : decision;
+          }
+        }
+
+        // Fallback: show CLI permission UI
+        return new Promise((resolve) => {
+          setPendingToolPermission({
+            request: req,
+            resolve: (decision) => {
+              setPendingToolPermission(null);
+              // Immediately reflect the decision in the status indicator so the running
+              // spinner appears without waiting for the event buffer to drain
+              const isAccept =
+                decision === "accept" ||
+                decision === "allowAlways" ||
+                decision === "background" ||
+                (typeof decision === "object" && decision.type === "accept_with_message") ||
+                (typeof decision === "object" && decision.type === "question_answers");
+              setAgentStatus(isAccept ? AgentStatus.ExecutingTool : AgentStatus.Submitted);
+              resolve(decision);
+            },
+          });
+          setAgentStatus(AgentStatus.WaitingForToolPermission);
+          void notifyActionRequired("Abacus.AI is waiting for your input");
+        });
+      },
+    );
+  }, [notifyActionRequired]);
+
+  const sessionRef = useRef<AgentSession | null>(null);
+
+  function createSession(): AgentSession {
+    return new AgentSession({
+      allowedDirectories: [cwd],
+      primaryWorkspace: cwd,
+      apiClient,
+      mode: agentModeRef.current,
+      permissionProvider,
+      diagnosticsProvider: {
+        getDiagnostics: async (files?: string[]): Promise<Diagnostic[]> => {
+          const conn = connectionRef.current;
+          if (!conn) return [];
+          return conn.getDiagnostics(files) as Promise<Diagnostic[]>;
+        },
+      },
+    });
+  }
+
+  if (!sessionRef.current) {
+    sessionRef.current = createSession();
+  }
+
+  const session = sessionRef.current;
+
+  useEffect(() => {
+    agentModeRef.current = agentMode;
+    session.setMode(agentMode);
+  }, [agentMode, session]);
+
+  useEffect(() => {
+    if (agentArgs?.conversationId) {
+      void loadConversation(agentArgs.conversationId);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  // Progress indicator side effects
+  useEffect(() => {
+    switch (agentStatus) {
+      case AgentStatus.Submitted:
+      case AgentStatus.Streaming:
+        showProgress({ state: "indeterminate", label: "Processing" });
+        break;
+      case AgentStatus.ExecutingTool:
+        showProgress({ state: "indeterminate", label: "Executing tools" });
+        break;
+      case AgentStatus.WaitingForToolPermission:
+        hideProgress();
+        break;
+      case AgentStatus.Idle:
+        hideProgress();
+        break;
+    }
+  }, [agentStatus]);
+
+  const addNotification = useCallback(
+    (message: string, severity: "info" | "warning" | "error" = "info", temp = false) => {
+      const seg: HistorySegment = {
+        id: crypto.randomUUID(),
+        status: "completed",
+        source: "bot",
+        type: "code_llm_notification",
+        severity,
+        message,
+        temp,
+      };
+      dispatchSegments({ type: "ADD_NOTIFICATION", seg });
+    },
+    [],
+  );
+
+  const clearSegments = useCallback(() => {
+    dispatchSegments({ type: "CLEAR" });
+    setConversationTitle(null);
+    setAgentStatus(AgentStatus.Idle);
+    conversationIdRef.current = null;
+    displayDataMapRef.current.clear();
+    sessionRef.current = createSession();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [apiClient, cwd, permissionProvider]);
+
+  const clearSegmentsOnly = useCallback(() => {
+    dispatchSegments({ type: "CLEAR" });
+  }, []);
+
+  const clearTempSegments = useCallback(() => {
+    dispatchSegments({ type: "REMOVE_TEMP" });
+  }, []);
+
+  const stop = useCallback(() => {
+    const first = session.dequeue();
+    session.clearQueue();
+    setQueuedMessages([]);
+    if (first !== null) {
+      setDequeuedOnStop(first);
+    }
+    session.stop();
+    setPendingToolPermission(null);
+    setAgentStatus(AgentStatus.Idle);
+  }, [session]);
+
+  const rejectPendingPermission = useCallback(() => {
+    if (pendingToolPermission) {
+      pendingToolPermission.resolve("reject");
+    }
+  }, [pendingToolPermission]);
+
+  const loadConversation = useCallback(
+    async (id: string) => {
+      setAgentStatus(AgentStatus.LoadingConversation);
+      dispatchSegments({ type: "CLEAR" });
+      setConversationTitle(null);
+      conversationIdRef.current = id;
+      try {
+        const result = await session.loadConversation(id);
+
+        if (result.title) {
+          setConversationTitle(result.title);
+        }
+
+        if (result.segments.length > 0) {
+          // Convert ConversationSegment[] to HistorySegment[] for existing CLI rendering
+          dispatchSegments({
+            type: "LOAD",
+            segments: result.segments.map((seg) => conversationSegmentToHistory(seg)),
+          });
+        }
+      } catch {
+        addNotification("Failed to load conversation", "error");
+      } finally {
+        setAgentStatus(AgentStatus.Idle);
+      }
+    },
+    [session, addNotification],
+  );
+
+  const refreshMcpTools = useCallback(
+    async (_skipReload?: boolean, showNotification?: boolean) => {
+      await session.mcp.refresh();
+      if (showNotification) {
+        addNotification("MCP tools refreshed", "info", true);
+      }
+    },
+    [session, addNotification],
+  );
+
+  const sendMessage = useCallback(
+    async ({
+      message,
+      selectedModel,
+      fileAttachments,
+    }: {
+      message: string;
+      selectedModel?: string;
+      fileAttachments?: FileAttachment[];
+    }) => {
+      if (!message) return;
+      if (agentStatus === AgentStatus.LoadingConversation) return;
+
+      if (selectedModel) session.setModel(selectedModel);
+
+      // Attach file content to message
+      let fullMessage = message;
+      if (fileAttachments && fileAttachments.length > 0) {
+        const textAttachments = fileAttachments.filter((a) => !a.mimeType.startsWith("image/"));
+        for (const attachment of textAttachments) {
+          const content =
+            typeof attachment.content === "string"
+              ? attachment.content
+              : attachment.content.toString("utf-8");
+          fullMessage += `\n\n<file path="${attachment.filePath}">\n${content}\n</file>`;
+        }
+      }
+
+      const userSegId = crypto.randomUUID();
+      const userSeg: HistorySegment = {
+        id: userSegId,
+        status: "completed",
+        source: "user",
+        type: "text",
+        segment: message,
+      };
+      const spinnySeg: HistorySegment = {
+        id: crypto.randomUUID(),
+        status: "transient",
+        source: "bot",
+        type: "collapsible_component",
+        title: "Processing request",
+        temp: true,
+        isSpinny: true,
+      };
+      dispatchSegments({ type: "INIT_SEND", userSeg, spinnySeg });
+
+      setAgentStatus(AgentStatus.Submitted);
+      startUpload();
+
+      let currentTextSegId: string | null = null;
+      let currentThinkingSegId: string | null = null;
+
+      let diagnosticIssues: string | undefined;
+      const conn = connectionRef.current;
+      const currentFile = conn?.getCurrentFile();
+      const selectionRange = conn?.getSelectionRange();
+      if (conn && currentFile) {
+        try {
+          const diags = (await conn.getDiagnostics([currentFile])) as Diagnostic[];
+          const issues = diags.filter((d) => d.severity === "error" || d.severity === "warning");
+          if (issues.length > 0) {
+            diagnosticIssues = issues
+              .map((d) => `${d.file}:${d.line}:${d.column} [${d.severity}] ${d.message}`)
+              .join("\n");
+          }
+        } catch {
+          // ignore diagnostics errors
+        }
+      }
+
+      try {
+        for await (const event of session.send(fullMessage, {
+          diagnosticIssues,
+          currentFile: currentFile ?? undefined,
+          selectionStartLine: selectionRange?.startLine,
+          selectionEndLine: selectionRange?.endLine,
+        })) {
+          switch (event.type) {
+            case "text_delta": {
+              setAgentStatus(AgentStatus.Streaming);
+              stopActivity();
+              startDownload();
+
+              const content = event.content;
+              if (!currentTextSegId) {
+                currentTextSegId = crypto.randomUUID();
+              }
+              const segId = currentTextSegId;
+              startSegmentTransition(() => {
+                dispatchSegments({ type: "TEXT_DELTA", segId, content });
+              });
+              break;
+            }
+
+            case "thinking_delta": {
+              const content = event.content;
+              if (!currentThinkingSegId) {
+                currentThinkingSegId = crypto.randomUUID();
+              }
+              const thinkSegId = currentThinkingSegId;
+              const thinkStart = Date.now();
+              startSegmentTransition(() => {
+                dispatchSegments({
+                  type: "THINKING_DELTA",
+                  segId: thinkSegId,
+                  content,
+                  startTime: thinkStart,
+                });
+              });
+              break;
+            }
+
+            case "thinking_complete": {
+              if (currentThinkingSegId) {
+                const segId = currentThinkingSegId;
+                const endTime = Date.now();
+                dispatchSegments({ type: "THINKING_COMPLETE", segId, endTime });
+                currentThinkingSegId = null;
+              }
+              break;
+            }
+
+            case "tool_display_data": {
+              const { toolCallId, data } = event;
+              const current = displayDataMapRef.current.get(toolCallId) ?? {};
+              displayDataMapRef.current.set(toolCallId, { ...current, ...data });
+              // Update any already-existing segment for this toolCallId
+              dispatchSegments({ type: "TOOL_DISPLAY_DATA", toolCallId, data });
+              break;
+            }
+
+            case "tool_requested": {
+              setAgentStatus(AgentStatus.ExecutingTool);
+              stopActivity();
+              startUpload();
+
+              const toolCallId = event.tool.id;
+              const toolSeg: HistorySegment = {
+                id: toolCallId,
+                status: "transient",
+                source: "bot",
+                type: "code_llm_tool_call",
+                toolUseRequest: {
+                  id: toolCallId,
+                  name: event.tool.name,
+                  input: event.tool.input,
+                },
+                toolDisplayData: displayDataMapRef.current.get(toolCallId),
+              } as HistorySegment;
+              dispatchSegments({
+                type: "TOOL_REQUESTED",
+                toolCallId,
+                textSegId: currentTextSegId,
+                toolSeg,
+              });
+              currentTextSegId = null;
+              break;
+            }
+
+            case "tool_execution_complete": {
+              stopActivity();
+              startDownload();
+
+              const toolCallId = event.tool.id;
+              const { parsedResult, ...rawResult } = event.result;
+              const spinnySeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "transient",
+                source: "bot",
+                type: "collapsible_component",
+                title: "Analyzing result",
+                temp: true,
+                isSpinny: true,
+              } as HistorySegment;
+              dispatchSegments({
+                type: "TOOL_EXECUTION_COMPLETE",
+                toolCallId,
+                rawResult,
+                ...(parsedResult !== undefined && { parsedResult }),
+                spinnySeg,
+              });
+              currentTextSegId = null;
+              break;
+            }
+
+            case "notification": {
+              if (event.severity === "error" || event.severity === "warning") {
+                addNotification(event.message, event.severity, false);
+              }
+              break;
+            }
+
+            case "error": {
+              const errorSeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "completed",
+                source: "bot",
+                type: "code_llm_notification",
+                severity: "error",
+                message: event.error.message,
+              } as HistorySegment;
+              dispatchSegments({ type: "ERROR", errorSeg });
+              break;
+            }
+
+            case "mode_changed": {
+              setAgentMode(event.mode);
+              break;
+            }
+
+            case "tool_user_message": {
+              const userMsgSeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "completed",
+                source: "user",
+                type: "text",
+                segment: event.message,
+              } as HistorySegment;
+              dispatchSegments({ type: "TOOL_USER_MESSAGE", seg: userMsgSeg });
+              break;
+            }
+
+            case "retry": {
+              setRetryState({
+                attempt: event.attempt,
+                maxAttempts: event.maxAttempts,
+                delayMs: event.delayMs,
+                isNetworkError: event.isNetworkError,
+              });
+              break;
+            }
+
+            case "network_status": {
+              setNetworkOnline(event.online);
+              if (event.online) {
+                setRetryState(null);
+              }
+              break;
+            }
+
+            case "user_message_dequeued": {
+              // A queued user message is now being processed. Render it as a user
+              // turn in the conversation, replacing the existing spinner with a
+              // fresh one so the UI shows the correct turn structure.
+              const dequeuedUserSeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "completed",
+                source: "user",
+                type: "text",
+                segment: event.content,
+              };
+              const newSpinnySeg: HistorySegment = {
+                id: crypto.randomUUID(),
+                status: "transient",
+                source: "bot",
+                type: "collapsible_component",
+                title: "Processing request",
+                temp: true,
+                isSpinny: true,
+              };
+              dispatchSegments({
+                type: "INIT_SEND",
+                userSeg: dequeuedUserSeg,
+                spinnySeg: newSpinnySeg,
+              });
+              // The dequeued message is no longer in the queue; sync display state.
+              setQueuedMessages(session.getQueue());
+              // Reset so the next text_delta produces a fresh streaming segment.
+              currentTextSegId = null;
+              currentThinkingSegId = null;
+              break;
+            }
+
+            case "turn_complete": {
+              if (currentTextSegId) {
+                const segId = currentTextSegId;
+                dispatchSegments({ type: "TEXT_COMPLETED", segId });
+                currentTextSegId = null;
+              }
+              // Sync React queue state in case AgentRunner consumed a queued message
+              // inline (Anthropic/OpenAI path) — keeps the queue pill accurate.
+              setQueuedMessages(session.getQueue());
+              break;
+            }
+          }
+        }
+      } catch (err) {
+        // Auth expired — trigger logout flow (unless env-based auth)
+        if (err instanceof AuthExpiredError) {
+          if (!authManager.isEnvAuth()) {
+            setAuthExpired(true);
+            void authManager.logout();
+          }
+          dispatchSegments({ type: "REMOVE_USER_SEG", userSegId });
+          addNotification("Session expired — use /login to authenticate again.", "error");
+        } else {
+          const errorMessage =
+            err instanceof NetworkError
+              ? "Unable to connect to API"
+              : err instanceof Error
+                ? err.message
+                : "An error occurred";
+          dispatchSegments({ type: "REMOVE_USER_SEG", userSegId });
+          addNotification(errorMessage, "error");
+        }
+
+        // Restore message to input buffer on error
+        setDequeuedOnStop(fullMessage);
+        // Clear the queue — messages won't be processed after a failure
+        session.clearQueue();
+        setQueuedMessages([]);
+      } finally {
+        stopActivity();
+        setRetryState(null);
+        // Finalize transient text segment and remove all spinny transient segments
+        dispatchSegments({ type: "FINALIZE", textSegId: currentTextSegId });
+        setAgentStatus(AgentStatus.Idle);
+        void notifyTaskComplete("Abacus.AI completed the task");
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      session,
+      agentStatus,
+      addNotification,
+      notifyTaskComplete,
+      startUpload,
+      startDownload,
+      stopActivity,
+      startSegmentTransition,
+      setAgentMode,
+      authManager,
+      setAuthExpired,
+    ],
+  );
+
+  const addToQueue = useCallback(
+    (message: string) => {
+      session.enqueue(message);
+      setQueuedMessages(session.getQueue());
+    },
+    [session],
+  );
+
+  const removeFirstFromQueue = useCallback(() => {
+    session.dequeue();
+    setQueuedMessages(session.getQueue());
+  }, [session]);
+
+  const clearQueue = useCallback(() => {
+    session.clearQueue();
+    setQueuedMessages([]);
+  }, [session]);
+
+  const clearDequeuedOnStop = useCallback(() => {
+    setDequeuedOnStop(null);
+  }, []);
+
+  const addAllowedDirectory = useCallback(
+    (dirPath: string) => session.addAllowedDirectory(dirPath),
+    [session],
+  );
+
+  const contextValue = useMemo<AgentContextValue>(
+    () => ({
+      conversationId: conversationIdRef.current,
+      conversationTitle,
+      segments,
+      segmentsLength: segments.length,
+      sendMessage,
+      stop,
+      rejectPendingPermission,
+      agentStatus,
+      clearSegments,
+      clearSegmentsOnly,
+      clearTempSegments,
+      loadConversation,
+      addNotification,
+      mcp: session.mcp,
+      addAllowedDirectory,
+      pendingToolPermission,
+      refreshMcpTools,
+      isPendingSegmentUpdate,
+      queuedMessages,
+      addToQueue,
+      removeFirstFromQueue,
+      clearQueue,
+      dequeuedOnStop,
+      clearDequeuedOnStop,
+      activeToolOutputs,
+      retryState,
+      networkOnline,
+    }),
+    [
+      conversationTitle,
+      segments,
+      sendMessage,
+      stop,
+      rejectPendingPermission,
+      agentStatus,
+      clearSegments,
+      clearSegmentsOnly,
+      clearTempSegments,
+      loadConversation,
+      addNotification,
+      session,
+      addAllowedDirectory,
+      pendingToolPermission,
+      refreshMcpTools,
+      isPendingSegmentUpdate,
+      queuedMessages,
+      addToQueue,
+      removeFirstFromQueue,
+      clearQueue,
+      dequeuedOnStop,
+      clearDequeuedOnStop,
+      retryState,
+      networkOnline,
+    ],
+  );
+
+  return <AgentContext.Provider value={contextValue}>{children}</AgentContext.Provider>;
+});
+
+AgentProvider.displayName = "AgentProvider";