@seqyuan/annodex 0.1.11 → 0.1.12

package/hooks/useAgentSession.ts

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