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

package/src/providers/agent.tsx

@@ -1,1075 +0,0 @@
-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";