@seqyuan/annodex 0.1.12 → 0.1.14

package/hooks/useAgentSession.ts

@@ -1,710 +0,0 @@
-"use client";
-
-import { useState, useCallback, useRef, useEffect, useReducer } from "react";
-import type { AgentMessage, SessionInfo, SubagentRun } from "@/lib/types";
-import { normalizeToolCalls } from "@/lib/normalize";
-import { sendAgentCommand } from "@/lib/agent-client";
-import type { ToolEntry } from "@/components/ToolPanel";
-import { coerceSubagentRuns, mergeSubagentRuns } from "@/lib/subagent-progress";
-
-export interface SessionData {
-  sessionId: string;
-  filePath: string;
-  info?: SessionInfo | null;
-  leafId: string | null;
-  context: {
-    messages: AgentMessage[];
-    entryIds: string[];
-    thinkingLevel: string;
-    model: { provider: string; modelId: string } | null;
-    subagentRuns?: SubagentRun[];
-    sessionStats?: { tokens: { input: number; output: number; cacheRead: number; cacheWrite: number }; cost?: number } | null;
-    contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null;
-  };
-}
-
-interface StreamingState {
-  isStreaming: boolean;
-  streamingMessage: Partial<AgentMessage> | null;
-}
-
-type StreamAction =
-  | { type: "start" }
-  | { type: "update"; message: Partial<AgentMessage> }
-  | { type: "end" }
-  | { type: "reset" };
-
-function streamReducer(state: StreamingState, action: StreamAction): StreamingState {
-  switch (action.type) {
-    case "start":
-      return { isStreaming: true, streamingMessage: null };
-    case "update":
-      return { isStreaming: true, streamingMessage: action.message };
-    case "end":
-    case "reset":
-      return { isStreaming: false, streamingMessage: null };
-    default:
-      return state;
-  }
-}
-
-interface AgentEvent {
-  type: string;
-  [key: string]: unknown;
-}
-
-type AgentCommandResult<T> = T & { __sessionId?: string };
-
-export type AgentPhase =
-  | { kind: "waiting_model" }
-  | { kind: "running_tools"; tools: { id: string; name: string }[] }
-  | null;
-
-export interface UseAgentSessionOptions {
-  session: SessionInfo | null;
-  newSessionCwd: string | null;
-  onAgentEnd?: () => void;
-  onSessionCreated?: (session: SessionInfo) => void;
-  onSessionForked?: (newSessionId: string) => void;
-  modelsRefreshKey?: number;
-  chatInputRef?: React.RefObject<ChatInputHandle | null>;
-  onSystemPromptChange?: (prompt: string | null) => void;
-  setNewSessionModel?: (model: { provider: string; modelId: string } | null) => void;
-  setToolPreset?: (preset: "none" | "default" | "full") => void;
-}
-
-export type ThinkingLevelOption = "auto" | "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
-
-export interface ChatInputHandle {
-  insertText: (text: string) => void;
-  insertIfEmpty: (content: string) => void;
-  addImages: (files: File[]) => void;
-  addFiles: (files: File[]) => void;
-}
-
-export interface AttachedImage {
-  data: string;
-  mimeType: string;
-  previewUrl: string;
-}
-
-export interface AttachedDocument {
-  data: ArrayBuffer;
-  fileName: string;
-  mimeType: string;
-  size: number;
-  extractedText?: string;
-  extractionError?: string;
-  truncated?: boolean;
-}
-
-export function useAgentSession(opts: UseAgentSessionOptions) {
-  const {
-    session, newSessionCwd, onAgentEnd, onSessionCreated, onSessionForked,
-    modelsRefreshKey, onSystemPromptChange,
-  } = opts;
-
-  const isNew = session === null && newSessionCwd !== null;
-
-  const [data, setData] = useState<SessionData | null>(null);
-  const [loading, setLoading] = useState(!isNew);
-  const [error, setError] = useState<string | null>(null);
-  const [messages, setMessages] = useState<AgentMessage[]>([]);
-  const [entryIds, setEntryIds] = useState<string[]>([]);
-  const [streamState, dispatch] = useReducer(streamReducer, { isStreaming: false, streamingMessage: null });
-  const [agentRunning, setAgentRunning] = useState(false);
-  const [modelNames, setModelNames] = useState<Record<string, string>>({});
-  const [modelList, setModelList] = useState<{ id: string; name: string; provider: string }[]>([]);
-  const [modelThinkingLevels, setModelThinkingLevels] = useState<Record<string, string[]>>({});
-  const [modelThinkingLevelMaps, setModelThinkingLevelMaps] = useState<Record<string, Record<string, string | null>>>({});
-  const [newSessionModel, setNewSessionModelState] = useState<{ provider: string; modelId: string } | null>(null);
-  const [toolPreset, setToolPreset] = useState<"none" | "default" | "full">("full");
-  const [thinkingLevel, setThinkingLevel] = useState<ThinkingLevelOption>("auto");
-  const [retryInfo, setRetryInfo] = useState<{ attempt: number; maxAttempts: number; errorMessage?: string } | null>(null);
-  const [contextUsage, setContextUsage] = useState<{ percent: number | null; contextWindow: number; tokens: number | null } | null>(null);
-  const [systemPrompt, setSystemPrompt] = useState<string | null>(null);
-  const [forkingEntryId, setForkingEntryId] = useState<string | null>(null);
-  const [currentModelOverride, setCurrentModelOverride] = useState<{ provider: string; modelId: string } | null>(null);
-  const [pendingModel, setPendingModel] = useState<{ provider: string; modelId: string } | null>(null);
-  const [isCompacting, setIsCompacting] = useState(false);
-  const [compactError, setCompactError] = useState<string | null>(null);
-  const [agentPhase, setAgentPhase] = useState<AgentPhase>(null);
-  const [agentError, setAgentError] = useState<string | null>(null);
-  const [subagentRuns, setSubagentRuns] = useState<SubagentRun[]>([]);
-
-  const eventSourceRef = useRef<EventSource | null>(null);
-  const sessionIdRef = useRef<string | null>(session?.id ?? null);
-  const agentRunningRef = useRef(false);
-  const handleAgentEventRef = useRef<((event: AgentEvent) => void) | null>(null);
-  const initialScrollDoneRef = useRef(false);
-  const lastUserMsgRef = useRef<HTMLDivElement | null>(null);
-  const pendingScrollToUserRef = useRef(false);
-  const messagesEndRef = useRef<HTMLDivElement | null>(null);
-  const scrollContainerRef = useRef<HTMLDivElement | null>(null);
-  // Skip the session-change useEffect when handleSend already connected EventSource
-  const skipSessionEffectRef = useRef(false);
-
-  const setNewSessionModel = opts.setNewSessionModel ?? setNewSessionModelState;
-  const setToolPresetState = opts.setToolPreset ?? setToolPreset;
-
-  const currentModel = currentModelOverride ?? data?.context.model ?? pendingModel ?? null;
-  const displayModel = isNew ? newSessionModel : currentModel;
-
-  const buildDocumentAppendix = useCallback((documents?: AttachedDocument[]) => {
-    if (!documents?.length) return "";
-    return documents.map((doc, index) => {
-      const header = `Attachment ${index + 1}: ${doc.fileName} (${doc.mimeType || "application/octet-stream"}, ${doc.size} bytes)`;
-      if (doc.extractedText) {
-        const note = doc.truncated ? "\n[The extracted text was truncated before sending.]" : "";
-        return `${header}\n${note}\n${doc.extractedText}`.trim();
-      }
-      return `${header}\n[Text extraction unavailable: ${doc.extractionError ?? "unsupported file type"}]`;
-    }).join("\n\n---\n\n");
-  }, []);
-
-  const messageSessionStats = (() => {
-    const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-    let cost = 0;
-    for (const msg of messages) {
-      if (msg.role !== "assistant") continue;
-      const u = (msg as import("@/lib/types").AssistantMessage).usage;
-      if (!u) continue;
-      tokens.input += u.input ?? 0;
-      tokens.output += u.output ?? 0;
-      tokens.cacheRead += u.cacheRead ?? 0;
-      tokens.cacheWrite += u.cacheWrite ?? 0;
-      cost += u.cost?.total ?? 0;
-    }
-    const total = tokens.input + tokens.output + tokens.cacheRead + tokens.cacheWrite;
-    return total > 0 ? { tokens, cost } : null;
-  })();
-  const sessionStats = data?.context.sessionStats ?? messageSessionStats;
-
-  const loadSession = useCallback(async (sid: string, showLoading = false, includeState = false) => {
-    try {
-      if (showLoading) setLoading(true);
-      const url = includeState
-        ? `/api/sessions/${encodeURIComponent(sid)}?includeState`
-        : `/api/sessions/${encodeURIComponent(sid)}`;
-      const res = await fetch(url);
-      if (res.status === 404) {
-        if (showLoading) {
-          setData(null);
-          setMessages([]);
-          setError(null);
-        }
-        return null;
-      }
-      if (!res.ok) throw new Error(`HTTP ${res.status}`);
-      const d = await res.json() as SessionData & { agentState?: { running: boolean; state?: { isStreaming?: boolean; isCompacting?: boolean; contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null; systemPrompt?: string; thinkingLevel?: string } } };
-      setData(d);
-      setMessages(d.context.messages);
-      setEntryIds(d.context.entryIds ?? []);
-      setSubagentRuns(d.context.subagentRuns ?? []);
-      if (!d.agentState?.state?.contextUsage && d.context.contextUsage !== undefined) {
-        setContextUsage(d.context.contextUsage ?? null);
-      }
-      setCurrentModelOverride(null);
-      setError(null);
-      // If no live agent state, fall back to thinking level from session file
-      if (!d.agentState?.state?.thinkingLevel && d.context.thinkingLevel && d.context.thinkingLevel !== "off") {
-        setThinkingLevel(d.context.thinkingLevel as ThinkingLevelOption);
-      }
-      return d.agentState ?? null;
-    } catch (e) {
-      setError(String(e));
-      return null;
-    } finally {
-      if (showLoading) setLoading(false);
-    }
-  }, []);
-
-  const loadTools = useCallback(async (sid: string) => {
-    try {
-      const tools = await sendAgentCommand<ToolEntry[]>(sid, { type: "get_tools" });
-      if (tools) {
-        const { getPresetFromTools } = await import("@/components/ToolPanel");
-        setToolPresetState(getPresetFromTools(tools));
-      }
-    } catch (e) {
-      console.error("Failed to load tools:", e);
-    }
-  }, [setToolPresetState]);
-
-  const connectEvents = useCallback((sid: string) => {
-    if (eventSourceRef.current) {
-      eventSourceRef.current.close();
-      eventSourceRef.current = null;
-    }
-    const es = new EventSource(`/api/agent/${encodeURIComponent(sid)}/events`);
-    eventSourceRef.current = es;
-    es.onmessage = (e) => {
-      try {
-        const event = JSON.parse(e.data) as AgentEvent;
-        handleAgentEventRef.current?.(event);
-      } catch {
-        // ignore
-      }
-    };
-    es.onerror = () => {
-      if (eventSourceRef.current === es && agentRunningRef.current) {
-        es.close();
-        eventSourceRef.current = null;
-        setTimeout(() => {
-          if (agentRunningRef.current) connectEvents(sid);
-        }, 1000);
-      }
-    };
-  }, []);
-
-  const waitForEventsConnected = useCallback((sid: string, timeoutMs = 5000) => {
-    return new Promise<void>((resolve) => {
-      const startedAt = Date.now();
-      const tick = () => {
-        if (eventSourceRef.current?.readyState === EventSource.OPEN) {
-          resolve();
-          return;
-        }
-        if (Date.now() - startedAt >= timeoutMs) {
-          resolve();
-          return;
-        }
-        setTimeout(tick, 50);
-      };
-      connectEvents(sid);
-      tick();
-    });
-  }, [connectEvents]);
-
-  useEffect(() => {
-    agentRunningRef.current = agentRunning;
-  }, [agentRunning]);
-
-  const handleAgentEvent = useCallback((event: AgentEvent) => {
-    switch (event.type) {
-      case "connected": {
-        const replacementSessionId = typeof event.sessionId === "string" ? event.sessionId : null;
-        if (replacementSessionId && sessionIdRef.current && replacementSessionId !== sessionIdRef.current) {
-          sessionIdRef.current = replacementSessionId;
-          onSessionForked?.(replacementSessionId);
-        }
-        break;
-      }
-      case "agent_start":
-        setAgentError(null);
-        setAgentRunning(true);
-        agentRunningRef.current = true;
-        setAgentPhase({ kind: "waiting_model" });
-        dispatch({ type: "start" });
-        break;
-      case "agent_end":
-        setAgentRunning(false);
-        agentRunningRef.current = false;
-        setAgentPhase(null);
-        setRetryInfo(null);
-        setAgentError(typeof event.error === "string" ? event.error : null);
-        dispatch({ type: "end" });
-        if (sessionIdRef.current) {
-          loadSession(sessionIdRef.current);
-          fetch(`/api/agent/${encodeURIComponent(sessionIdRef.current)}`)
-            .then((r) => r.json())
-            .then((d: { state?: { contextUsage?: { percent: number | null; contextWindow: number; tokens: number | null } | null; systemPrompt?: string } }) => {
-              if (d.state?.contextUsage !== undefined) setContextUsage(d.state.contextUsage ?? null);
-              if (d.state?.systemPrompt !== undefined) setSystemPrompt(d.state.systemPrompt ?? null);
-            })
-            .catch(() => {});
-        }
-        onAgentEnd?.();
-        break;
-      case "message_start":
-      case "message_update": {
-        const msg = event.message as Partial<AgentMessage> | undefined;
-        if (msg) {
-          dispatch({ type: "update", message: normalizeToolCalls(msg as AgentMessage) });
-        }
-        setAgentPhase(null);
-        break;
-      }
-      case "message_end": {
-        const completed = event.message as AgentMessage | undefined;
-        if (completed) {
-          setMessages((prev) => [...prev, normalizeToolCalls(completed)]);
-        }
-        dispatch({ type: "reset" });
-        setAgentPhase({ kind: "waiting_model" });
-        break;
-      }
-      case "tool_execution_start": {
-        const id = event.toolCallId as string;
-        const name = event.toolName as string;
-        setAgentPhase((prev) => {
-          const tools = prev?.kind === "running_tools" ? [...prev.tools] : [];
-          if (!tools.some((t) => t.id === id)) tools.push({ id, name });
-          return { kind: "running_tools", tools };
-        });
-        break;
-      }
-      case "tool_execution_end": {
-        const id = event.toolCallId as string;
-        setAgentPhase((prev) => {
-          if (prev?.kind !== "running_tools") return prev;
-          const tools = prev.tools.filter((t) => t.id !== id);
-          if (tools.length === 0) return { kind: "waiting_model" };
-          return { kind: "running_tools", tools };
-        });
-        break;
-      }
-      case "subagent_progress": {
-        const runs = coerceSubagentRuns(event.runs);
-        if (runs.length > 0) {
-          setSubagentRuns((prev) => mergeSubagentRuns(prev, runs));
-          const activeRuns = runs.filter((run) => run.status === "running" || run.status === "pending");
-          if (activeRuns.length > 0) {
-            setAgentPhase({
-              kind: "running_tools",
-              tools: activeRuns.map((run) => ({ id: run.id, name: run.agent })),
-            });
-          }
-        }
-        break;
-      }
-      case "auto_retry_start":
-        setRetryInfo({ attempt: event.attempt as number, maxAttempts: event.maxAttempts as number, errorMessage: event.errorMessage as string | undefined });
-        break;
-      case "auto_retry_end":
-        setRetryInfo(null);
-        break;
-      case "auto_compaction_start":
-      case "compaction_start":
-        setIsCompacting(true);
-        setCompactError(null);
-        break;
-      case "auto_compaction_end":
-      case "compaction_end":
-        setIsCompacting(false);
-        if (event.errorMessage) {
-          setCompactError(event.errorMessage as string);
-        } else if (!event.aborted) {
-          if (sessionIdRef.current) loadSession(sessionIdRef.current);
-        }
-        break;
-    }
-  }, [loadSession, onAgentEnd, onSessionForked]);
-  handleAgentEventRef.current = handleAgentEvent;
-
-  const handleSend = useCallback(async (message: string, images?: AttachedImage[], documents?: AttachedDocument[]) => {
-    if (!message.trim() && !images?.length && !documents?.length) return;
-    if (agentRunning) return;
-
-    const docRefs = buildDocumentAppendix(documents);
-    const fullMessage = message.trim()
-      ? (docRefs ? `${message}\n\nAttached document text:\n\n${docRefs}` : message)
-      : (docRefs ? `Attached document text:\n\n${docRefs}` : "");
-
-    const imageBlocks = images?.map((img) => ({ type: "image" as const, source: { type: "base64" as const, media_type: img.mimeType, data: img.data } }));
-    const userMsg: AgentMessage = {
-      role: "user",
-      content: imageBlocks?.length
-        ? [...(fullMessage.trim() ? [{ type: "text" as const, text: fullMessage }] : []), ...imageBlocks]
-        : fullMessage,
-      timestamp: Date.now(),
-    };
-    setMessages((prev) => [...prev, userMsg]);
-    setAgentError(null);
-    setAgentRunning(true);
-    agentRunningRef.current = true;
-    setAgentPhase({ kind: "waiting_model" });
-    dispatch({ type: "start" });
-    pendingScrollToUserRef.current = true;
-
-    const piImages = images?.map((img) => ({ type: "image" as const, data: img.data, mimeType: img.mimeType }));
-
-    try {
-      if (isNew && newSessionCwd) {
-        const selectedModel = newSessionModel;
-        if (selectedModel) setPendingModel(selectedModel);
-        const { PRESET_NONE, PRESET_DEFAULT, PRESET_FULL } = await import("@/components/ToolPanel");
-        const toolNames = toolPreset === "none" ? PRESET_NONE : toolPreset === "default" ? PRESET_DEFAULT : PRESET_FULL;
-        const res = await fetch("/api/agent/new", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            cwd: newSessionCwd,
-            toolNames,
-            ...(selectedModel ? { provider: selectedModel.provider, modelId: selectedModel.modelId } : {}),
-            ...(thinkingLevel !== "auto" ? { thinkingLevel } : {}),
-          }),
-        });
-        const result = await res.json().catch(() => ({})) as { sessionId?: string; error?: string };
-        if (!res.ok || result.error || !result.sessionId) {
-          throw new Error(result.error ?? `HTTP ${res.status}`);
-        }
-        const realId = result.sessionId;
-        sessionIdRef.current = realId;
-        await waitForEventsConnected(realId);
-        await sendAgentCommand(realId, {
-          type: "prompt",
-          message: fullMessage,
-          toolNames,
-          ...(piImages?.length ? { images: piImages } : {}),
-        });
-        skipSessionEffectRef.current = true;
-        onSessionCreated?.({
-          id: realId,
-          path: "",
-          cwd: newSessionCwd,
-          name: undefined,
-          created: new Date().toISOString(),
-          modified: new Date().toISOString(),
-          messageCount: 1,
-          firstMessage: message,
-        });
-      } else if (session) {
-        const { PRESET_NONE, PRESET_DEFAULT, PRESET_FULL } = await import("@/components/ToolPanel");
-        const toolNames = toolPreset === "none" ? PRESET_NONE : toolPreset === "default" ? PRESET_DEFAULT : PRESET_FULL;
-        await waitForEventsConnected(session.id);
-        const promptResult = await sendAgentCommand<Record<string, unknown>>(session.id, {
-          type: "prompt",
-          message: fullMessage,
-          toolNames,
-          ...(piImages?.length ? { images: piImages } : {}),
-        });
-        if (promptResult?.__sessionId && promptResult.__sessionId !== session.id) {
-          sessionIdRef.current = promptResult.__sessionId;
-          connectEvents(promptResult.__sessionId);
-          onSessionForked?.(promptResult.__sessionId);
-        }
-      }
-    } catch (e) {
-      console.error("Failed to send message:", e);
-      setAgentError(e instanceof Error ? e.message : String(e));
-      setAgentRunning(false);
-      agentRunningRef.current = false;
-      setAgentPhase(null);
-      dispatch({ type: "end" });
-    }
-  }, [isNew, newSessionCwd, newSessionModel, toolPreset, thinkingLevel, session, agentRunning, waitForEventsConnected, onSessionCreated, onSessionForked, connectEvents, buildDocumentAppendix]);
-
-  const handleAbort = useCallback(async () => {
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    agentRunningRef.current = false;
-    setAgentError(null);
-    setAgentRunning(false);
-    setAgentPhase(null);
-    dispatch({ type: "end" });
-    eventSourceRef.current?.close();
-    eventSourceRef.current = null;
-    try {
-      await sendAgentCommand(sid, { type: "abort" });
-      await loadSession(sid);
-    } catch (e) {
-      console.error("Failed to abort:", e);
-      await loadSession(sid);
-    }
-  }, [loadSession]);
-
-  const handleFork = useCallback(async (entryId: string) => {
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    setForkingEntryId(entryId);
-    try {
-      const result = await sendAgentCommand<{ cancelled?: boolean; newSessionId?: string }>(sid, {
-        type: "fork",
-        entryId,
-      });
-      const { cancelled, newSessionId } = result ?? {};
-      if (!cancelled && newSessionId) {
-        onSessionForked?.(newSessionId);
-      }
-    } catch (e) {
-      console.error("Fork failed:", e);
-    } finally {
-      setForkingEntryId(null);
-    }
-  }, [onSessionForked]);
-
-  const handleModelChange = useCallback(async (provider: string, modelId: string) => {
-    if (isNew) {
-      setNewSessionModel({ provider, modelId });
-      return;
-    }
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    try {
-      const result: AgentCommandResult<{ id?: string; provider?: string; newSessionId?: string }> = await sendAgentCommand(sid, { type: "set_model", provider, modelId });
-      const replacementSessionId = result.newSessionId ?? result.__sessionId;
-      if (replacementSessionId && replacementSessionId !== sid) {
-        sessionIdRef.current = replacementSessionId;
-        onSessionForked?.(replacementSessionId);
-      }
-      setCurrentModelOverride({
-        provider: result?.provider ?? provider,
-        modelId: result?.id ?? modelId,
-      });
-    } catch (e) {
-      console.error("Failed to set model:", e);
-    }
-  }, [isNew, onSessionForked, setNewSessionModel]);
-
-  const handleCompact = useCallback(async () => {
-    const sid = sessionIdRef.current;
-    if (!sid || isCompacting) return;
-    setIsCompacting(true);
-    setCompactError(null);
-    try {
-      await sendAgentCommand(sid, { type: "compact" });
-      await loadSession(sid, true);
-    } catch (e) {
-      setCompactError(e instanceof Error ? e.message : String(e));
-    } finally {
-      setIsCompacting(false);
-    }
-  }, [isCompacting, loadSession]);
-
-  const handleAbortCompaction = useCallback(async () => {
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    try {
-      await sendAgentCommand(sid, { type: "abort_compaction" });
-    } catch (e) {
-      console.error("Failed to abort compaction:", e);
-    }
-  }, []);
-
-  const handleThinkingLevelChange = useCallback(async (level: ThinkingLevelOption) => {
-    setThinkingLevel(level);
-    if (level === "auto") return; // "auto" leaves codex's current setting untouched
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    try {
-      await sendAgentCommand(sid, { type: "set_thinking_level", level });
-    } catch (e) {
-      console.error("Failed to set thinking level:", e);
-    }
-  }, []);
-
-  const handleToolPresetChange = useCallback(async (preset: "none" | "default" | "full") => {
-    const { PRESET_NONE, PRESET_DEFAULT, PRESET_FULL } = await import("@/components/ToolPanel");
-    const toolNames = preset === "none" ? PRESET_NONE : preset === "default" ? PRESET_DEFAULT : PRESET_FULL;
-    setToolPresetState(preset);
-    const sid = sessionIdRef.current;
-    if (!sid) return;
-    try {
-      await sendAgentCommand(sid, { type: "set_tools", toolNames });
-    } catch (e) {
-      console.error("Failed to set tools:", e);
-    }
-  }, [setToolPresetState]);
-
-  const scrollToBottom = useCallback((behavior: ScrollBehavior = "smooth") => {
-    messagesEndRef.current?.scrollIntoView({ behavior });
-  }, []);
-
-  const scrollUserMsgToTop = useCallback(() => {
-    const container = scrollContainerRef.current;
-    const el = lastUserMsgRef.current;
-    if (!container || !el) return;
-    const elAbsTop = el.getBoundingClientRect().top - container.getBoundingClientRect().top + container.scrollTop;
-    container.scrollTo({ top: elAbsTop - 16, behavior: "smooth" });
-  }, []);
-
-  // Load session on mount or when session id changes (model switch fork)
-  useEffect(() => {
-    if (skipSessionEffectRef.current) {
-      // session created by handleSend — EventSource already connected, skip reload
-      skipSessionEffectRef.current = false;
-      return;
-    }
-    if (session) {
-      sessionIdRef.current = session.id;
-      loadSession(session.id, true, true).then((agentState) => {
-        if (agentState?.running) {
-          loadTools(session.id);
-          // Always reconnect when agent is running — not just when isStreaming.
-          // During tool execution isStreaming is false, but the agent is still
-          // active and we need to receive tool_result / agent_end events.
-          setAgentRunning(true);
-          setAgentPhase({ kind: "waiting_model" });
-          dispatch({ type: "start" });
-          connectEvents(session.id);
-        }
-        if (agentState?.state) {
-          if (agentState.state.isCompacting !== undefined) setIsCompacting(agentState.state.isCompacting);
-          if (agentState.state.contextUsage !== undefined) setContextUsage(agentState.state.contextUsage ?? null);
-          if (agentState.state.systemPrompt !== undefined) setSystemPrompt(agentState.state.systemPrompt ?? null);
-          if (agentState.state.thinkingLevel !== undefined) setThinkingLevel((agentState.state.thinkingLevel as ThinkingLevelOption) ?? "auto");
-        }
-      });
-    }
-    return () => {
-      eventSourceRef.current?.close();
-      eventSourceRef.current = null;
-    };
-  }, [session?.id]);
-
-  useEffect(() => {
-    onSystemPromptChange?.(systemPrompt);
-  }, [systemPrompt, onSystemPromptChange]);
-
-  useEffect(() => {
-    if (messages.length > 0) {
-      if (pendingScrollToUserRef.current) {
-        pendingScrollToUserRef.current = false;
-        initialScrollDoneRef.current = true;
-        scrollUserMsgToTop();
-      } else if (!initialScrollDoneRef.current) {
-        initialScrollDoneRef.current = true;
-        scrollToBottom("instant");
-      } else if (!agentRunningRef.current) {
-        scrollToBottom("smooth");
-      }
-    }
-  }, [messages.length, agentRunning, scrollToBottom, scrollUserMsgToTop]);
-
-  // Load model list
-  useEffect(() => {
-    fetch("/api/models").then((r) => r.json()).then((d: { models: Record<string, string>; modelList?: { id: string; name: string; provider: string }[]; defaultModel?: { provider: string; modelId: string } | null; thinkingLevels?: Record<string, string[]>; thinkingLevelMaps?: Record<string, Record<string, string | null>> }) => {
-      setModelNames(d.models);
-      if (d.thinkingLevels) setModelThinkingLevels(d.thinkingLevels);
-      if (d.thinkingLevelMaps) setModelThinkingLevelMaps(d.thinkingLevelMaps);
-      if (d.modelList) {
-        setModelList(d.modelList);
-        if (isNew) {
-          const def = d.defaultModel;
-          const match = def && d.modelList.find((m) => m.id === def.modelId && m.provider === def.provider);
-          setNewSessionModel(match
-            ? { provider: match.provider, modelId: match.id }
-            : def ?? null);
-        }
-      }
-    }).catch(() => {});
-  }, [isNew, modelsRefreshKey, setNewSessionModel]);
-
-  // Compact error auto-dismiss
-  useEffect(() => {
-    if (!compactError) return;
-    const t = setTimeout(() => setCompactError(null), 3000);
-    return () => clearTimeout(t);
-  }, [compactError]);
-
-  return {
-    // State
-    data, loading, error, messages, entryIds, streamState,
-    agentRunning, modelNames, modelList, modelThinkingLevels, modelThinkingLevelMaps, newSessionModel, toolPreset, thinkingLevel,
-    retryInfo, contextUsage, systemPrompt, forkingEntryId,
-    isCompacting, compactError, currentModel, displayModel, sessionStats,
-    agentPhase, agentError, subagentRuns,
-    isNew,
-    // Refs
-    sessionIdRef, eventSourceRef, messagesEndRef, scrollContainerRef,
-    lastUserMsgRef, pendingScrollToUserRef, initialScrollDoneRef,
-    // Actions
-    handleSend, handleAbort, handleFork, handleModelChange,
-    handleCompact, handleAbortCompaction,
-    handleToolPresetChange, handleThinkingLevelChange, loadTools, setData, setMessages,
-    dispatch, setAgentRunning, setForkingEntryId,
-    // Subscriptions
-    handleAgentEventRef,
-  };
-}