@ottocode/web-sdk 0.1.272 → 0.1.274

package/dist/hooks/index.js

@@ -228,6 +228,7 @@ import {
   generateCommitMessage as apiGenerateCommitMessage,
   pushCommits as apiPushCommits,
   pullChanges as apiPullChanges,
+  performGitRebaseAction as apiPerformGitRebaseAction,
   initGitRepo as apiInitGitRepo,
   getGitRemotes as apiGetGitRemotes,
   addGitRemote as apiAddGitRemote,
@@ -235,7 +236,9 @@ import {
 } from "@ottocode/api";
 var gitMixin = {
   async initGitRepo() {
-    const response = await apiInitGitRepo();
+    const response = await apiInitGitRepo({
+      body: {}
+    });
     if (response.error)
       throw new Error(extractErrorMessage(response.error));
     return response.data?.data;
@@ -336,6 +339,14 @@ var gitMixin = {
       throw new Error(extractErrorMessage(response.error));
     return response.data?.data;
   },
+  async performRebaseAction(action) {
+    const response = await apiPerformGitRebaseAction({
+      body: { action }
+    });
+    if (response.error)
+      throw new Error(extractErrorMessage(response.error));
+    return response.data?.data;
+  },
   async getRemotes() {
     const response = await apiGetGitRemotes();
     if (response.error)
@@ -903,6 +914,7 @@ class ApiClient {
   getGitBranch = gitMixin.getGitBranch;
   pushCommits = gitMixin.pushCommits;
   pullChanges = gitMixin.pullChanges;
+  performRebaseAction = gitMixin.performRebaseAction;
   getRemotes = gitMixin.getRemotes;
   addRemote = gitMixin.addRemote;
   removeRemote = gitMixin.removeRemote;
@@ -1057,6 +1069,12 @@ function openPlatformSession(sessionId) {
   win.OTTO_OPEN_SESSION(sessionId);
   return true;
 }
+function getPlatformWindowFocused() {
+  const win = getPlatformWindow();
+  if (!win?.OTTO_IS_WINDOW_FOCUSED)
+    return null;
+  return win.OTTO_IS_WINDOW_FOCUSED();
+}
 function hasPlatformOpenUrl() {
   return !!getPlatformWindow()?.OTTO_OPEN_URL;
 }
@@ -1221,6 +1239,17 @@ import { create } from "zustand";
 function titleFromPath(path) {
   return path.split("/").pop() || path;
 }
+function normalizeViewerPath(path) {
+  return path.trim().replace(/^a\//, "").replace(/^b\//, "").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/+$/, "");
+}
+function viewerPathsMatch(left, right) {
+  const normalizedLeft = normalizeViewerPath(left);
+  const normalizedRight = normalizeViewerPath(right);
+  return normalizedLeft === normalizedRight || normalizedLeft.endsWith(`/${normalizedRight}`) || normalizedRight.endsWith(`/${normalizedLeft}`);
+}
+function fileTabId(path) {
+  return `file:${normalizeViewerPath(path)}`;
+}
 function upsertTab(tabs, tab) {
   const existingIndex = tabs.findIndex((item) => item.id === tab.id);
   if (existingIndex === -1) {
@@ -1230,9 +1259,32 @@ function upsertTab(tabs, tab) {
   next[existingIndex] = tab;
   return next;
 }
+function isSamePatchCall(existing, preview) {
+  if (!existing)
+    return false;
+  if (preview.callId || existing.callId) {
+    return Boolean(preview.callId && existing.callId === preview.callId);
+  }
+  if (preview.status === "streaming" && existing.status !== "streaming") {
+    return false;
+  }
+  if (!preview.patch || !existing.patch)
+    return existing.status === "streaming";
+  return preview.patch === existing.patch || preview.patch.startsWith(existing.patch) || existing.patch.startsWith(preview.patch);
+}
+function mergeChangedLines(existing, incoming) {
+  if (!existing?.length)
+    return incoming;
+  if (!incoming?.length)
+    return existing;
+  return [...new Set([...existing, ...incoming])].sort((a, b) => a - b);
+}
 var useViewerTabsStore = create((set) => ({
   tabs: [],
   activeTabId: null,
+  followToolActivity: false,
+  toggleFollowToolActivity: () => set((state) => ({ followToolActivity: !state.followToolActivity })),
+  setFollowToolActivity: (enabled) => set({ followToolActivity: enabled }),
   openGitDiffTab: (path, staged) => {
     const id = `git-diff:${staged ? "staged" : "unstaged"}:${path}`;
     set((state) => ({
@@ -1261,16 +1313,130 @@ var useViewerTabsStore = create((set) => ({
     }));
   },
   openFileTab: (path) => {
-    const id = `file:${path}`;
-    set((state) => ({
-      tabs: upsertTab(state.tabs, {
-        id,
-        type: "file",
-        title: titleFromPath(path),
-        path
-      }),
-      activeTabId: id
-    }));
+    const id = fileTabId(path);
+    set((state) => {
+      const matchingFileTabs = state.tabs.filter((tab) => tab.type === "file" && viewerPathsMatch(tab.path, path));
+      const existingFile = matchingFileTabs.find((tab) => tab.id === state.activeTabId) ?? matchingFileTabs[0];
+      const targetId = existingFile?.id ?? id;
+      const targetPath = existingFile?.path ?? path;
+      const tabs = state.tabs.filter((tab) => !((tab.type === "tool-preview" || tab.type === "file") && tab.id !== targetId && viewerPathsMatch(tab.path, path)));
+      return {
+        tabs: upsertTab(tabs, {
+          id: targetId,
+          type: "file",
+          title: existingFile?.title ?? titleFromPath(targetPath),
+          path: targetPath
+        }),
+        activeTabId: targetId
+      };
+    });
+  },
+  openToolReadTab: (path, highlight) => {
+    const id = fileTabId(path);
+    set((state) => {
+      const matchingFileTabs = state.tabs.filter((tab) => tab.type === "file" && viewerPathsMatch(tab.path, path));
+      const existingFile = matchingFileTabs.find((tab) => tab.id === state.activeTabId) ?? matchingFileTabs[0];
+      const targetId = existingFile?.id ?? id;
+      const targetPath = existingFile?.path ?? path;
+      const tabs = state.tabs.filter((tab) => !((tab.type === "tool-preview" || tab.type === "file") && tab.id !== targetId && viewerPathsMatch(tab.path, path)));
+      return {
+        tabs: upsertTab(tabs, {
+          id: targetId,
+          type: "file",
+          title: existingFile?.title ?? titleFromPath(targetPath),
+          path: targetPath,
+          highlight,
+          patchPreview: undefined,
+          writePreview: undefined
+        }),
+        activeTabId: targetId
+      };
+    });
+  },
+  openToolPreviewTab: (preview) => {
+    const id = fileTabId(preview.path);
+    set((state) => {
+      const matchingFileTabs = state.tabs.filter((tab) => tab.type === "file" && viewerPathsMatch(tab.path, preview.path));
+      const existingFile = matchingFileTabs.find((tab) => tab.id === state.activeTabId) ?? matchingFileTabs[0];
+      const targetId = existingFile?.id ?? id;
+      const targetPath = existingFile?.path ?? preview.path;
+      const existing = state.tabs.find((tab) => tab.type === "tool-preview" && viewerPathsMatch(tab.path, preview.path));
+      const tabs = state.tabs.filter((tab) => !((tab.type === "tool-preview" || tab.type === "file") && tab.id !== targetId && (viewerPathsMatch(tab.path, preview.path) || Boolean(preview.callId && "toolName" in tab && tab.callId === preview.callId))));
+      if (preview.toolName === "apply_patch") {
+        const existingPatchPreview = existingFile?.patchPreview ?? (existing?.toolName === "apply_patch" ? existing : undefined);
+        const samePatchCall = isSamePatchCall(existingPatchPreview, preview);
+        const baseContent = preview.baseContent ?? (samePatchCall ? existingPatchPreview?.baseContent : existingPatchPreview?.resultContent ?? existingPatchPreview?.baseContent);
+        const changedLines = samePatchCall ? preview.changedLines ?? existingPatchPreview?.changedLines : mergeChangedLines(existingPatchPreview?.changedLines, preview.changedLines);
+        return {
+          tabs: upsertTab(tabs, {
+            id: targetId,
+            type: "file",
+            title: existingFile?.title ?? titleFromPath(targetPath),
+            path: targetPath,
+            highlight: undefined,
+            writePreview: undefined,
+            patchPreview: {
+              path: targetPath,
+              toolName: "apply_patch",
+              callId: preview.callId ?? existingPatchPreview?.callId,
+              baseContent,
+              patch: preview.patch ?? existingPatchPreview?.patch,
+              changedLines,
+              previewContent: preview.previewContent ?? (samePatchCall ? existingPatchPreview?.previewContent : undefined),
+              resultContent: preview.resultContent ?? (samePatchCall ? existingPatchPreview?.resultContent : undefined),
+              previewLineTones: preview.previewLineTones ?? (samePatchCall ? existingPatchPreview?.previewLineTones : undefined),
+              previewFirstLine: preview.previewFirstLine ?? (samePatchCall ? existingPatchPreview?.previewFirstLine : undefined),
+              previewLatestLine: preview.previewLatestLine ?? (samePatchCall ? existingPatchPreview?.previewLatestLine : undefined),
+              status: preview.status,
+              error: preview.error ?? existingPatchPreview?.error
+            }
+          }),
+          activeTabId: targetId
+        };
+      }
+      if (existingFile) {
+        const existingWritePreview = existingFile.writePreview;
+        return {
+          tabs: upsertTab(tabs, {
+            ...existingFile,
+            highlight: undefined,
+            patchPreview: undefined,
+            writePreview: {
+              path: targetPath,
+              toolName: "write",
+              callId: preview.callId ?? existingWritePreview?.callId,
+              content: preview.content ?? existingWritePreview?.content,
+              status: preview.status,
+              error: preview.error ?? existingWritePreview?.error
+            }
+          }),
+          activeTabId: targetId
+        };
+      }
+      const existingWrite = existing?.toolName === "write" ? existing : undefined;
+      return {
+        tabs: upsertTab(tabs, {
+          id,
+          type: "tool-preview",
+          title: titleFromPath(preview.path),
+          path: preview.path,
+          toolName: preview.toolName,
+          callId: preview.callId,
+          content: preview.content ?? existingWrite?.content,
+          baseContent: undefined,
+          patch: undefined,
+          changedLines: undefined,
+          previewContent: undefined,
+          resultContent: undefined,
+          previewLineTones: undefined,
+          previewFirstLine: undefined,
+          previewLatestLine: undefined,
+          status: preview.status,
+          error: preview.error ?? existingWrite?.error
+        }),
+        activeTabId: id
+      };
+    });
   },
   openSkillFileTab: (skill, file) => {
     const displayFile = file ?? "SKILL.md";
@@ -1811,6 +1977,16 @@ function usePullChanges() {
     }
   });
 }
+function useGitRebaseAction() {
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: (action) => apiClient.performRebaseAction(action),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["git", "status"] });
+      queryClient.invalidateQueries({ queryKey: ["git", "branch"] });
+    }
+  });
+}
 function useGitInit() {
   const queryClient = useQueryClient2();
   return useMutation2({
@@ -1852,7 +2028,71 @@ function useRemoveRemote() {
   });
 }
 // src/hooks/useMessages.ts
-import { useQuery as useQuery4, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+import { useQuery as useQuery5, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+
+// src/hooks/useQueueState.ts
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+var defaultQueueState = {
+  currentMessageId: null,
+  queuedMessages: [],
+  queueLength: 0
+};
+function optimisticallyQueueMessage(queryClient, sessionId, messageId) {
+  queryClient.setQueryData(["queueState", sessionId], (current) => {
+    if (!current)
+      return current;
+    const isBusy = Boolean(current.currentMessageId) || current.queuedMessages.length > 0 || current.queueLength > 0;
+    if (!isBusy)
+      return current;
+    if (current.currentMessageId === messageId)
+      return current;
+    if (current.queuedMessages.some((item) => item.messageId === messageId)) {
+      return current;
+    }
+    const queuedMessages = [
+      ...current.queuedMessages,
+      { messageId, position: current.queuedMessages.length }
+    ];
+    return {
+      ...current,
+      queuedMessages,
+      queueLength: queuedMessages.length
+    };
+  });
+}
+function useQueueState(sessionId) {
+  const { data } = useQuery4({
+    queryKey: ["queueState", sessionId],
+    queryFn: async () => {
+      if (!sessionId)
+        return defaultQueueState;
+      const queueState = await apiClient.getQueueState(sessionId);
+      return {
+        currentMessageId: queueState.currentMessageId,
+        queuedMessages: queueState.queuedMessages,
+        queueLength: queueState.queuedMessages.length
+      };
+    },
+    enabled: !!sessionId,
+    placeholderData: defaultQueueState,
+    staleTime: Infinity
+  });
+  return data ?? defaultQueueState;
+}
+function useMessageQueuePosition(sessionId, messageId) {
+  const queueState = useQueueState(sessionId);
+  if (!sessionId || !queueState) {
+    return { isQueued: false, isRunning: false, position: null };
+  }
+  if (queueState.currentMessageId === messageId) {
+    return { isQueued: false, isRunning: true, position: null };
+  }
+  const queuedItem = queueState.queuedMessages.find((item) => item.messageId === messageId);
+  if (queuedItem) {
+    return { isQueued: true, isRunning: false, position: queuedItem.position };
+  }
+  return { isQueued: false, isRunning: false, position: null };
+}
 
 // src/hooks/useSessions.ts
 import {
@@ -1963,7 +2203,7 @@ function useDeleteSession() {
 // src/hooks/useMessages.ts
 function useMessages(sessionId, options = {}) {
   const { enabled = true, staleTime = 15000 } = options;
-  return useQuery4({
+  return useQuery5({
     queryKey: ["messages", sessionId],
     queryFn: () => {
       if (!sessionId) {
@@ -1985,7 +2225,8 @@ function useSendMessage(sessionId) {
       });
       return apiClient.sendMessage(sessionId, data);
     },
-    onSuccess: () => {
+    onSuccess: (result) => {
+      optimisticallyQueueMessage(queryClient, sessionId, result.messageId);
       queryClient.invalidateQueries({ queryKey: ["messages", sessionId] });
       queryClient.invalidateQueries({ queryKey: sessionsQueryKey });
     }
@@ -2125,10 +2366,22 @@ var useToolApprovalStore = create10((set) => ({
 }));
 
 // src/hooks/useSessionStream.ts
+var TOOL_PREVIEW_THROTTLE_MS = 500;
+var TOOL_PREVIEW_THROTTLE_MIN_CHARS = 8000;
+var TOOL_PREVIEW_THROTTLE_MIN_DELTA_CHARS = 16000;
+var STREAMING_WRITE_CONTENT_PREVIEW_CHARS = 24000;
+var STREAMING_PATCH_PREVIEW_HEAD_CHARS = 12000;
+var STREAMING_PATCH_PREVIEW_TAIL_CHARS = 24000;
+var STREAMING_TOOL_INPUT_HEAD_CHARS = 8000;
+var STREAMING_TOOL_INPUT_TAIL_CHARS = 16000;
+var STREAMING_TOOL_MESSAGE_THROTTLE_MS = 500;
 function useSessionStream(sessionId, enabled = true) {
   const queryClient = useQueryClient5();
   const clientRef = useRef(null);
   const assistantMessageIdRef = useRef(null);
+  const toolInputBuffersRef = useRef(new Map);
+  const toolPreviewEmitRef = useRef(new Map);
+  const toolMessageEmitRef = useRef(new Map);
   const {
     addPendingApproval,
     removePendingApproval,
@@ -2140,6 +2393,9 @@ function useSessionStream(sessionId, enabled = true) {
       return;
     }
     assistantMessageIdRef.current = null;
+    toolInputBuffersRef.current.clear();
+    toolPreviewEmitRef.current.clear();
+    toolMessageEmitRef.current.clear();
     let lastSessionInvalidation = 0;
     apiClient.getPendingApprovals(sessionId).then((result) => {
       if (result.ok && result.pending.length > 0) {
@@ -2163,7 +2419,7 @@ function useSessionStream(sessionId, enabled = true) {
       }
       for (let i = messages.length - 1;i >= 0; i -= 1) {
         const candidate = messages[i];
-        if (candidate.role === "assistant" && candidate.status !== "complete") {
+        if (candidate.role === "assistant" && candidate.status === "pending") {
           return i;
         }
       }
@@ -2194,6 +2450,388 @@ function useSessionStream(sessionId, enabled = true) {
       return typeof payload?.toolName === "string" ? payload.toolName : null;
     };
     const getToolEventArgs = (payload) => payload?.args ?? payload?.input;
+    const getToolBufferKey = (payload) => {
+      const callId = getToolEventCallId(payload);
+      if (callId)
+        return callId;
+      const name = getToolEventName(payload);
+      return name ? `name:${name}` : null;
+    };
+    const parseArgsRecord = (value) => {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+      }
+      if (typeof value !== "string")
+        return null;
+      try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+      } catch {
+        return null;
+      }
+    };
+    const normalizeLineNumber = (value) => {
+      const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+      return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : undefined;
+    };
+    const parseLineRange = (value) => {
+      if (typeof value !== "string")
+        return {};
+      const match = value.match(/@(\d+)(?:-(\d+))?/);
+      if (!match)
+        return {};
+      return {
+        startLine: normalizeLineNumber(match[1]),
+        endLine: normalizeLineNumber(match[2] ?? match[1])
+      };
+    };
+    const getBoundedStreamingToolInput = (value) => {
+      const maxLength = STREAMING_TOOL_INPUT_HEAD_CHARS + STREAMING_TOOL_INPUT_TAIL_CHARS;
+      if (value.length <= maxLength)
+        return value;
+      return `${value.slice(0, STREAMING_TOOL_INPUT_HEAD_CHARS)}
+… streamed tool input truncated for UI responsiveness …
+${value.slice(-STREAMING_TOOL_INPUT_TAIL_CHARS)}`;
+    };
+    const getToolArgsForViewer = (payload, delta) => {
+      const args = parseArgsRecord(getToolEventArgs(payload));
+      if (args)
+        return args;
+      const key = getToolBufferKey(payload);
+      if (!key)
+        return null;
+      const previous = toolInputBuffersRef.current.get(key) ?? "";
+      if (!delta)
+        return parseArgsRecord(previous);
+      const next = getBoundedStreamingToolInput(`${previous}${delta}`);
+      toolInputBuffersRef.current.set(key, next);
+      return parseArgsRecord(next);
+    };
+    const bestEffortUnescapeJsonString = (value) => {
+      try {
+        return JSON.parse(`"${value.replace(/\\$/, "")}"`);
+      } catch {
+        return value.replace(/\\n/g, `
+`).replace(/\\t/g, "\t").replace(/\\r/g, "\r").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+      }
+    };
+    const extractJsonStringField = (text, field, requireClosed = false) => {
+      const marker = `"${field}"`;
+      const markerIndex = text.indexOf(marker);
+      if (markerIndex === -1)
+        return;
+      const colonIndex = text.indexOf(":", markerIndex + marker.length);
+      if (colonIndex === -1)
+        return;
+      const quoteIndex = text.indexOf('"', colonIndex + 1);
+      if (quoteIndex === -1)
+        return;
+      let escaped = "";
+      let escaping = false;
+      let closed = false;
+      for (let i = quoteIndex + 1;i < text.length; i += 1) {
+        const char = text[i];
+        if (escaping) {
+          escaped += `\\${char}`;
+          escaping = false;
+          continue;
+        }
+        if (char === "\\") {
+          escaping = true;
+          continue;
+        }
+        if (char === '"') {
+          closed = true;
+          break;
+        }
+        escaped += char;
+      }
+      if (requireClosed && !closed)
+        return;
+      return bestEffortUnescapeJsonString(escaped);
+    };
+    const getBufferedToolInput = (payload) => {
+      const key = getToolBufferKey(payload);
+      return key ? toolInputBuffersRef.current.get(key) ?? "" : "";
+    };
+    const getStringArg = (args, buffer, field, requireClosed = false) => {
+      const value = args?.[field];
+      if (typeof value === "string")
+        return value;
+      return extractJsonStringField(buffer, field, requireClosed);
+    };
+    const getStreamingWritePreviewContent = (args, buffer) => {
+      const argContent = args?.content;
+      if (typeof argContent === "string") {
+        if (argContent.length <= STREAMING_WRITE_CONTENT_PREVIEW_CHARS) {
+          return argContent;
+        }
+        return `… showing latest streamed content only …
+${argContent.slice(-STREAMING_WRITE_CONTENT_PREVIEW_CHARS)}`;
+      }
+      const marker = '"content"';
+      const markerIndex = buffer.indexOf(marker);
+      if (markerIndex === -1)
+        return;
+      const colonIndex = buffer.indexOf(":", markerIndex + marker.length);
+      if (colonIndex === -1)
+        return;
+      const quoteIndex = buffer.indexOf('"', colonIndex + 1);
+      if (quoteIndex === -1)
+        return;
+      const valueStart = quoteIndex + 1;
+      if (buffer.length - valueStart <= STREAMING_WRITE_CONTENT_PREVIEW_CHARS) {
+        return extractJsonStringField(buffer, "content");
+      }
+      const rawTail = buffer.slice(Math.max(valueStart, buffer.length - STREAMING_WRITE_CONTENT_PREVIEW_CHARS));
+      return `… showing latest streamed content only …
+${bestEffortUnescapeJsonString(rawTail)}`;
+    };
+    const getStreamingPatchPreviewContent = (args, buffer) => {
+      const argPatch = args?.patch;
+      if (typeof argPatch === "string") {
+        if (argPatch.length <= STREAMING_PATCH_PREVIEW_HEAD_CHARS + STREAMING_PATCH_PREVIEW_TAIL_CHARS) {
+          return argPatch;
+        }
+        return `${argPatch.slice(0, STREAMING_PATCH_PREVIEW_HEAD_CHARS)}
+… patch preview truncated while streaming …
+${argPatch.slice(-STREAMING_PATCH_PREVIEW_TAIL_CHARS)}`;
+      }
+      const marker = '"patch"';
+      const markerIndex = buffer.indexOf(marker);
+      if (markerIndex === -1)
+        return;
+      const colonIndex = buffer.indexOf(":", markerIndex + marker.length);
+      if (colonIndex === -1)
+        return;
+      const quoteIndex = buffer.indexOf('"', colonIndex + 1);
+      if (quoteIndex === -1)
+        return;
+      const valueStart = quoteIndex + 1;
+      const rawLength = buffer.length - valueStart;
+      if (rawLength <= STREAMING_PATCH_PREVIEW_HEAD_CHARS + STREAMING_PATCH_PREVIEW_TAIL_CHARS) {
+        return extractJsonStringField(buffer, "patch");
+      }
+      const rawHead = buffer.slice(valueStart, valueStart + STREAMING_PATCH_PREVIEW_HEAD_CHARS);
+      const rawTail = buffer.slice(-STREAMING_PATCH_PREVIEW_TAIL_CHARS);
+      return `${bestEffortUnescapeJsonString(rawHead)}
+… patch preview truncated while streaming …
+${bestEffortUnescapeJsonString(rawTail)}`;
+    };
+    const getResultRecord = (payload) => payload?.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? payload.result : null;
+    const getArtifactRecord = (payload) => payload?.artifact && typeof payload.artifact === "object" && !Array.isArray(payload.artifact) ? payload.artifact : null;
+    const extractErrorMessage2 = (payload) => {
+      const result = getResultRecord(payload);
+      if (typeof payload?.error === "string")
+        return payload.error;
+      return typeof result?.error === "string" ? result.error : undefined;
+    };
+    const normalizePatchPath = (path) => path.replace(/^a\//, "").replace(/^b\//, "").trim();
+    const patchPathMatches = (patchPath, targetPath) => {
+      const normalizedPatch = normalizePatchPath(patchPath);
+      const normalizedTarget = normalizePatchPath(targetPath);
+      return normalizedPatch === normalizedTarget || normalizedPatch.endsWith(`/${normalizedTarget}`) || normalizedTarget.endsWith(`/${normalizedPatch}`);
+    };
+    const patchPathMayReferToTarget = (patchPath, targetPath) => {
+      const normalizedPatch = normalizePatchPath(patchPath).replace(/\/+$/, "");
+      const normalizedTarget = normalizePatchPath(targetPath);
+      if (!normalizedPatch)
+        return false;
+      return patchPathMatches(patchPath, targetPath) || normalizedTarget.startsWith(`${normalizedPatch}/`);
+    };
+    const isLikelyCompletePatchPath = (path) => {
+      const normalized = normalizePatchPath(path);
+      if (!normalized || normalized.endsWith("/"))
+        return false;
+      const name = normalized.split("/").pop() ?? "";
+      return name.includes(".");
+    };
+    const getCompletedPatchChangeLineSignature = (patch) => {
+      const stablePatch = patch.endsWith(`
+`) ? patch : patch.slice(0, patch.lastIndexOf(`
+`) + 1);
+      if (!stablePatch)
+        return;
+      let changeLines = 0;
+      let stableChangeLength = 0;
+      for (const line of stablePatch.split(`
+`)) {
+        if (line.startsWith("+") && !line.startsWith("+++") || line.startsWith("-") && !line.startsWith("---")) {
+          changeLines += 1;
+          stableChangeLength += line.length;
+        }
+      }
+      return changeLines > 0 ? `${changeLines}:${stableChangeLength}` : undefined;
+    };
+    const extractPathsFromPatch = (patch) => {
+      const paths = new Set;
+      for (const line of patch.split(`
+`)) {
+        const directive = line.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/);
+        if (directive?.[1]) {
+          paths.add(directive[1].trim());
+          continue;
+        }
+        const unified = line.match(/^\+\+\+ (?:b\/)?(.+)$/);
+        if (unified?.[1] && unified[1] !== "/dev/null") {
+          paths.add(unified[1].trim());
+        }
+      }
+      return [...paths];
+    };
+    const getChangedLinesForPath = (result, path) => {
+      const changes = Array.isArray(result?.changes) ? result.changes : [];
+      const lines = new Set;
+      for (const change of changes) {
+        if (!change || typeof change !== "object")
+          continue;
+        const record = change;
+        if (typeof record.filePath !== "string")
+          continue;
+        if (!patchPathMatches(record.filePath, path))
+          continue;
+        if (!Array.isArray(record.hunks))
+          continue;
+        for (const hunk of record.hunks) {
+          if (!hunk || typeof hunk !== "object")
+            continue;
+          const hunkRecord = hunk;
+          const newStart = typeof hunkRecord.newStart === "number" ? hunkRecord.newStart : undefined;
+          const newLines = typeof hunkRecord.newLines === "number" ? hunkRecord.newLines : undefined;
+          if (!newStart || !newLines)
+            continue;
+          for (let line = newStart;line < newStart + newLines; line += 1) {
+            lines.add(line);
+          }
+        }
+      }
+      return lines.size > 0 ? [...lines] : undefined;
+    };
+    const handleReadToolActivity = (eventType, payload, delta) => {
+      const viewerStore = useViewerTabsStore.getState();
+      if (!viewerStore.followToolActivity)
+        return;
+      const name = getToolEventName(payload);
+      if (name !== "read")
+        return;
+      const args = getToolArgsForViewer(payload, delta);
+      const path = typeof args?.path === "string" ? args.path : null;
+      if (!path)
+        return;
+      const result = payload?.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? payload.result : null;
+      const rangeFromResult = parseLineRange(result?.lineRange);
+      const startLine = normalizeLineNumber(args.startLine) ?? normalizeLineNumber(args.start_line) ?? rangeFromResult.startLine;
+      const endLine = normalizeLineNumber(args.endLine) ?? normalizeLineNumber(args.end_line) ?? rangeFromResult.endLine ?? startLine;
+      const failed = result?.ok === false || eventType === "error";
+      viewerStore.openToolReadTab(path, {
+        startLine,
+        endLine,
+        reason: "read",
+        callId: getToolEventCallId(payload) ?? undefined,
+        status: failed ? "error" : eventType === "tool.result" ? "success" : "streaming"
+      });
+    };
+    const handleWriteToolActivity = (eventType, payload, delta) => {
+      const viewerStore = useViewerTabsStore.getState();
+      if (!viewerStore.followToolActivity)
+        return;
+      const name = getToolEventName(payload);
+      if (name !== "write")
+        return;
+      const args = getToolArgsForViewer(payload, delta);
+      const buffer = getBufferedToolInput(payload);
+      const result = getResultRecord(payload);
+      const path = (typeof result?.path === "string" ? result.path : undefined) ?? getStringArg(args, buffer, "path", true);
+      if (!path)
+        return;
+      const failed = result?.ok === false || eventType === "error";
+      const callId = getToolEventCallId(payload) ?? undefined;
+      const status = failed ? "error" : eventType === "tool.result" ? "success" : "streaming";
+      const content = status === "streaming" ? getStreamingWritePreviewContent(args, buffer) : getStringArg(args, buffer, "content");
+      if (status === "streaming" && content !== undefined && content.length >= TOOL_PREVIEW_THROTTLE_MIN_CHARS) {
+        const previewKey = callId ?? path;
+        const now = Date.now();
+        const last = toolPreviewEmitRef.current.get(previewKey);
+        const contentDelta = Math.abs(content.length - (last?.contentLength ?? 0));
+        if (last && now - last.emittedAt < TOOL_PREVIEW_THROTTLE_MS && contentDelta < TOOL_PREVIEW_THROTTLE_MIN_DELTA_CHARS) {
+          return;
+        }
+        toolPreviewEmitRef.current.set(previewKey, {
+          emittedAt: now,
+          contentLength: content.length
+        });
+      }
+      viewerStore.openToolPreviewTab({
+        path,
+        toolName: "write",
+        callId,
+        content,
+        status,
+        error: extractErrorMessage2(payload)
+      });
+    };
+    const handleApplyPatchToolActivity = (eventType, payload, delta) => {
+      const viewerStore = useViewerTabsStore.getState();
+      if (!viewerStore.followToolActivity)
+        return;
+      const name = getToolEventName(payload);
+      if (name !== "apply_patch")
+        return;
+      const args = getToolArgsForViewer(payload, delta);
+      const buffer = getBufferedToolInput(payload);
+      const artifact = getArtifactRecord(payload);
+      const result = getResultRecord(payload);
+      const failed = result?.ok === false || eventType === "error";
+      const status = failed ? "error" : eventType === "tool.result" ? "success" : "streaming";
+      const callId = getToolEventCallId(payload) ?? undefined;
+      const patch = (typeof artifact?.patch === "string" ? artifact.patch : undefined) ?? (status === "streaming" ? getStreamingPatchPreviewContent(args, buffer) : getStringArg(args, buffer, "patch"));
+      if (!patch)
+        return;
+      const previewKey = callId ?? "apply_patch";
+      const lineSignature = status === "streaming" ? getCompletedPatchChangeLineSignature(patch) : undefined;
+      if (status === "streaming") {
+        const last = toolPreviewEmitRef.current.get(previewKey);
+        if (last?.lineSignature === lineSignature)
+          return;
+      }
+      const patchPaths = extractPathsFromPatch(patch);
+      if (patchPaths.length === 0)
+        return;
+      const matchingFileTabs = viewerStore.tabs.filter((tab) => tab.type === "file" && patchPaths.some((path) => patchPathMayReferToTarget(path, tab.path)));
+      const activeMatchingFileTab = matchingFileTabs.find((tab) => tab.id === viewerStore.activeTabId);
+      const fallbackPath = patchPaths.find(isLikelyCompletePatchPath);
+      if (!activeMatchingFileTab && !matchingFileTabs[0] && !fallbackPath)
+        return;
+      const targetPath = activeMatchingFileTab?.path ?? matchingFileTabs[0]?.path ?? fallbackPath;
+      if (!targetPath)
+        return;
+      viewerStore.openToolPreviewTab({
+        path: targetPath,
+        toolName: "apply_patch",
+        callId,
+        patch,
+        changedLines: getChangedLinesForPath(result, targetPath),
+        status,
+        error: extractErrorMessage2(payload)
+      });
+      if (status === "streaming") {
+        toolPreviewEmitRef.current.set(previewKey, {
+          emittedAt: Date.now(),
+          contentLength: buffer.length,
+          lineSignature
+        });
+      }
+    };
+    const handleToolActivityViewerEvent = (eventType, payload, delta) => {
+      const name = getToolEventName(payload);
+      if (name === "read")
+        handleReadToolActivity(eventType, payload, delta);
+      if (name === "write")
+        handleWriteToolActivity(eventType, payload, delta);
+      if (name === "apply_patch") {
+        handleApplyPatchToolActivity(eventType, payload, delta);
+      }
+    };
     const getToolInputDelta = (payload) => {
       if (typeof payload?.delta === "string")
         return payload.delta;
@@ -2204,19 +2842,9 @@ function useSessionStream(sessionId, enabled = true) {
         return payload.delta;
       return typeof payload?.outputTextDelta === "string" ? payload.outputTextDelta : null;
     };
-    const getOptimisticPartIndex = (parts, stepIndex) => {
-      const appendIndex = (() => {
-        const indexes = parts.map((part) => part.index).filter((index) => Number.isFinite(index));
-        return indexes.length > 0 ? Math.max(...indexes) + 0.001 : 0;
-      })();
-      if (typeof stepIndex !== "number") {
-        return appendIndex;
-      }
-      const sameStepIndexes = parts.filter((part) => part.stepIndex === stepIndex).map((part) => part.index).filter((index) => Number.isFinite(index));
-      if (sameStepIndexes.length > 0) {
-        return Math.max(...sameStepIndexes) + 0.001;
-      }
-      return appendIndex;
+    const getOptimisticPartIndex = (parts, _stepIndex) => {
+      const indexes = parts.map((part) => part.index).filter((index) => Number.isFinite(index));
+      return indexes.length > 0 ? Math.max(...indexes) + 0.001 : 0;
     };
     const applyReasoningDelta = (payload) => {
       const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
@@ -2331,6 +2959,18 @@ function useSessionStream(sessionId, enabled = true) {
       const name = getToolEventName(payload);
       if (!name)
         return;
+      if (name === "write" || name === "apply_patch") {
+        const bufferKey = getToolBufferKey(payload);
+        const bufferedLength = bufferKey ? toolInputBuffersRef.current.get(bufferKey)?.length ?? 0 : 0;
+        if (bufferedLength >= TOOL_PREVIEW_THROTTLE_MIN_CHARS) {
+          const emitKey = callId ?? `name:${name}`;
+          const now = Date.now();
+          const last = toolMessageEmitRef.current.get(emitKey) ?? 0;
+          if (now - last < STREAMING_TOOL_MESSAGE_THROTTLE_MS)
+            return;
+          toolMessageEmitRef.current.set(emitKey, now);
+        }
+      }
       queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
         if (!oldMessages)
           return oldMessages;
@@ -2434,7 +3074,7 @@ function useSessionStream(sessionId, enabled = true) {
         if (partIndex === -1) {
           const contentJsonBase = {
             name,
-            _streamedInput: delta
+            _streamedInput: getBoundedStreamingToolInput(delta)
           };
           if (callId)
             contentJsonBase.callId = callId;
@@ -2462,7 +3102,7 @@ function useSessionStream(sessionId, enabled = true) {
           const prev = typeof existing.contentJson?._streamedInput === "string" ? existing.contentJson._streamedInput : "";
           const nextContentJson = {
             ...typeof existing.contentJson === "object" && !Array.isArray(existing.contentJson) ? existing.contentJson : {},
-            _streamedInput: prev + delta
+            _streamedInput: getBoundedStreamingToolInput(prev + delta)
           };
           parts[partIndex] = {
             ...existing,
@@ -2671,6 +3311,7 @@ function useSessionStream(sessionId, enabled = true) {
           const id = typeof payload?.id === "string" ? payload.id : null;
           if (role === "assistant" && id) {
             assistantMessageIdRef.current = id;
+            optimisticallyQueueMessage(queryClient, sessionId, id);
           }
           if (id && role) {
             const agent = typeof payload?.agent === "string" ? payload.agent : "";
@@ -2750,8 +3391,10 @@ function useSessionStream(sessionId, enabled = true) {
           if (channel === "input" || channel == null && delta) {
             if (delta) {
               accumulateToolInputDelta(payload, delta);
+              handleToolActivityViewerEvent("tool.delta", payload, delta);
             } else {
               upsertEphemeralToolCall(payload);
+              handleToolActivityViewerEvent("tool.delta", payload);
             }
           } else if (channel === "output" && delta) {
             accumulateToolOutputDelta(payload, delta);
@@ -2760,10 +3403,15 @@ function useSessionStream(sessionId, enabled = true) {
         }
         case "tool.call": {
           upsertEphemeralToolCall(payload);
+          handleToolActivityViewerEvent("tool.call", payload);
           break;
         }
         case "tool.result": {
           resolveEphemeralToolCall(payload);
+          handleToolActivityViewerEvent("tool.result", payload);
+          const key = getToolBufferKey(payload);
+          if (key)
+            toolInputBuffersRef.current.delete(key);
           break;
         }
         case "tool.approval.required": {
@@ -2798,10 +3446,30 @@ function useSessionStream(sessionId, enabled = true) {
           break;
         }
         case "error": {
+          handleToolActivityViewerEvent("error", payload);
           removeEphemeralToolCall(payload);
           const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
           if (messageId) {
+            if (assistantMessageIdRef.current === messageId) {
+              assistantMessageIdRef.current = null;
+            }
             clearEphemeralForMessage(messageId);
+            const errorMessage = typeof payload?.error === "string" ? payload.error : typeof payload?.message === "string" ? payload.message : "Assistant run failed";
+            queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
+              if (!oldMessages)
+                return oldMessages;
+              const idx = oldMessages.findIndex((m) => m.id === messageId);
+              if (idx === -1)
+                return oldMessages;
+              const next = [...oldMessages];
+              next[idx] = {
+                ...next[idx],
+                status: "error",
+                completedAt: next[idx].completedAt ?? Date.now(),
+                error: errorMessage
+              };
+              return next;
+            });
           }
           queryClient.invalidateQueries({ queryKey: ["messages", sessionId] });
           break;
@@ -2810,6 +3478,13 @@ function useSessionStream(sessionId, enabled = true) {
           const id = typeof payload?.id === "string" ? payload.id : null;
           const status = typeof payload?.status === "string" ? payload.status : null;
           if (id && status) {
+            if (status !== "pending" && assistantMessageIdRef.current === id) {
+              assistantMessageIdRef.current = null;
+            }
+            if (status !== "pending") {
+              clearEphemeralForMessage(id);
+            }
+            const error = typeof payload?.error === "string" ? payload.error : undefined;
             queryClient.setQueryData(["messages", sessionId], (oldMessages) => {
               if (!oldMessages)
                 return oldMessages;
@@ -2819,7 +3494,9 @@ function useSessionStream(sessionId, enabled = true) {
               const next = [...oldMessages];
               next[idx] = {
                 ...next[idx],
-                status
+                status,
+                completedAt: status === "pending" ? next[idx].completedAt : next[idx].completedAt ?? Date.now(),
+                error: error ?? next[idx].error
               };
               return next;
             });
@@ -3022,6 +3699,9 @@ function sendBrowserNotification(notification) {
   };
   return true;
 }
+function isAppForeground() {
+  return getPlatformWindowFocused() ?? document.visibilityState === "visible";
+}
 function updateSessionStatusInCache(queryClient, status) {
   queryClient.setQueryData(sessionsQueryKey, (old) => {
     if (!old)
@@ -3167,7 +3847,7 @@ function useClientEvents(activeSessionId) {
         }
         if (event.event === "notification") {
           const notification = payload;
-          const isActiveVisibleSession = notification.sessionId === activeSessionIdRef.current && document.visibilityState === "visible";
+          const isActiveVisibleSession = notification.sessionId === activeSessionIdRef.current && isAppForeground();
           const isSessionNotification = notification.source === "session" || !!notification.sessionId;
           let sentSystemNotification = false;
           if (!isActiveVisibleSession) {
@@ -3423,7 +4103,7 @@ function useKeyboardShortcuts({
       }
       return;
     }
-    if ((e.ctrlKey || e.metaKey) && e.key === "h") {
+    if ((e.ctrlKey || e.metaKey) && e.key === "b") {
       e.preventDefault();
       if (currentFocus === "sessions") {
         document.activeElement?.blur();
@@ -3446,7 +4126,7 @@ function useKeyboardShortcuts({
       }
       return;
     }
-    if ((e.ctrlKey || e.metaKey) && e.key === "l") {
+    if ((e.ctrlKey || e.metaKey) && !e.shiftKey && e.key === "r") {
       e.preventDefault();
       if (currentFocus === "git") {
         document.activeElement?.blur();
@@ -4162,10 +4842,10 @@ function useFileUpload(options = {}) {
   };
 }
 // src/hooks/useSessionFiles.ts
-import { useQuery as useQuery5 } from "@tanstack/react-query";
+import { useQuery as useQuery6 } from "@tanstack/react-query";
 function useSessionFiles(sessionId, enabled = true) {
   const isExpanded = useSessionFilesStore((state) => state.isExpanded);
-  return useQuery5({
+  return useQuery6({
     queryKey: ["session", sessionId, "files"],
     queryFn: () => sessionId ? apiClient.getSessionFiles(sessionId) : null,
     enabled: !!sessionId && enabled,
@@ -4174,46 +4854,6 @@ function useSessionFiles(sessionId, enabled = true) {
     staleTime: 3000
   });
 }
-// src/hooks/useQueueState.ts
-import { useQuery as useQuery6 } from "@tanstack/react-query";
-var defaultQueueState = {
-  currentMessageId: null,
-  queuedMessages: [],
-  queueLength: 0
-};
-function useQueueState(sessionId) {
-  const { data } = useQuery6({
-    queryKey: ["queueState", sessionId],
-    queryFn: async () => {
-      if (!sessionId)
-        return defaultQueueState;
-      const queueState = await apiClient.getQueueState(sessionId);
-      return {
-        currentMessageId: queueState.currentMessageId,
-        queuedMessages: queueState.queuedMessages,
-        queueLength: queueState.queuedMessages.length
-      };
-    },
-    enabled: !!sessionId,
-    placeholderData: defaultQueueState,
-    staleTime: Infinity
-  });
-  return data ?? defaultQueueState;
-}
-function useMessageQueuePosition(sessionId, messageId) {
-  const queueState = useQueueState(sessionId);
-  if (!sessionId || !queueState) {
-    return { isQueued: false, isRunning: false, position: null };
-  }
-  if (queueState.currentMessageId === messageId) {
-    return { isQueued: false, isRunning: true, position: null };
-  }
-  const queuedItem = queueState.queuedMessages.find((item) => item.messageId === messageId);
-  if (queuedItem) {
-    return { isQueued: true, isRunning: false, position: queuedItem.position };
-  }
-  return { isQueued: false, isRunning: false, position: null };
-}
 // src/hooks/useBranch.ts
 import { useQuery as useQuery7, useMutation as useMutation5, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
 function useCreateBranch(sessionId) {
@@ -5767,6 +6407,7 @@ export {
   useImageUpload,
   useGitStatus,
   useGitRemotes,
+  useGitRebaseAction,
   useGitInit,
   useGitDiffFullFile,
   useGitDiff,
@@ -5794,7 +6435,8 @@ export {
   useAllModels,
   useAddRemote,
   useAddMCPServer,
-  sessionsQueryKey
+  sessionsQueryKey,
+  optimisticallyQueueMessage
 };
 
-//# debugId=AFCFC55375F9489664756E2164756E21
+//# debugId=90296322954CBDC864756E2164756E21