@ottocode/web-sdk 0.1.272 → 0.1.273

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,9 @@ import { create } from "zustand";
 function titleFromPath(path) {
   return path.split("/").pop() || path;
 }
+function fileTabId(path) {
+  return `file:${path}`;
+}
 function upsertTab(tabs, tab) {
   const existingIndex = tabs.findIndex((item) => item.id === tab.id);
   if (existingIndex === -1) {
@@ -1230,9 +1251,25 @@ 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);
+}
 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 +1298,94 @@ 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 tabs = state.tabs.filter((tab) => !(tab.type === "tool-preview" && tab.path === path && tab.id !== id));
+      return {
+        tabs: upsertTab(tabs, {
+          id,
+          type: "file",
+          title: titleFromPath(path),
+          path
+        }),
+        activeTabId: id
+      };
+    });
+  },
+  openToolReadTab: (path, highlight) => {
+    const id = fileTabId(path);
+    set((state) => {
+      const tabs = state.tabs.filter((tab) => !(tab.type === "tool-preview" && tab.path === path && tab.id !== id));
+      return {
+        tabs: upsertTab(tabs, {
+          id,
+          type: "file",
+          title: titleFromPath(path),
+          path,
+          highlight
+        }),
+        activeTabId: id
+      };
+    });
+  },
+  openToolPreviewTab: (preview) => {
+    const id = fileTabId(preview.path);
+    set((state) => {
+      const existingFile = state.tabs.find((tab) => tab.id === id && tab.type === "file");
+      const existing = state.tabs.find((tab) => tab.id === id && tab.type === "tool-preview");
+      const tabs = state.tabs.filter((tab) => !(tab.type === "tool-preview" && tab.id !== id && (tab.path === preview.path || Boolean(preview.callId && tab.callId === preview.callId))));
+      if (preview.toolName === "apply_patch" && existingFile) {
+        const existingPatchPreview = existingFile.patchPreview;
+        const samePatchCall = isSamePatchCall(existingPatchPreview, preview);
+        const baseContent2 = preview.baseContent ?? (samePatchCall ? existingPatchPreview?.baseContent : existingPatchPreview?.resultContent ?? existingPatchPreview?.baseContent);
+        return {
+          tabs: upsertTab(tabs, {
+            ...existingFile,
+            highlight: undefined,
+            patchPreview: {
+              path: preview.path,
+              toolName: "apply_patch",
+              callId: preview.callId ?? existingPatchPreview?.callId,
+              baseContent: baseContent2,
+              patch: preview.patch ?? existingPatchPreview?.patch,
+              changedLines: preview.changedLines ?? (samePatchCall ? existingPatchPreview?.changedLines : undefined),
+              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: id
+        };
+      }
+      const sameToolPreviewCall = isSamePatchCall(existing, preview);
+      const baseContent = preview.toolName === "apply_patch" ? preview.baseContent ?? (sameToolPreviewCall ? existing?.baseContent : existing?.resultContent ?? existing?.baseContent) : 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 ?? existing?.content,
+          baseContent,
+          patch: preview.patch ?? existing?.patch,
+          changedLines: preview.changedLines ?? existing?.changedLines,
+          previewContent: preview.previewContent ?? (sameToolPreviewCall ? existing?.previewContent : undefined),
+          resultContent: preview.resultContent ?? (sameToolPreviewCall ? existing?.resultContent : undefined),
+          previewLineTones: preview.previewLineTones ?? (sameToolPreviewCall ? existing?.previewLineTones : undefined),
+          previewFirstLine: preview.previewFirstLine ?? (sameToolPreviewCall ? existing?.previewFirstLine : undefined),
+          previewLatestLine: preview.previewLatestLine ?? (sameToolPreviewCall ? existing?.previewLatestLine : undefined),
+          status: preview.status,
+          error: preview.error ?? existing?.error
+        }),
+        activeTabId: id
+      };
+    });
   },
   openSkillFileTab: (skill, file) => {
     const displayFile = file ?? "SKILL.md";
@@ -1811,6 +1926,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({
@@ -2125,10 +2250,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 +2277,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) {
@@ -2194,6 +2334,347 @@ 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 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;
+      if (status === "streaming" && buffer.length >= TOOL_PREVIEW_THROTTLE_MIN_CHARS) {
+        const previewKey = callId ?? "apply_patch";
+        const now = Date.now();
+        const last = toolPreviewEmitRef.current.get(previewKey);
+        const contentDelta = Math.abs(buffer.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: buffer.length
+        });
+      }
+      const patch = (typeof artifact?.patch === "string" ? artifact.patch : undefined) ?? (status === "streaming" ? getStreamingPatchPreviewContent(args, buffer) : getStringArg(args, buffer, "patch"));
+      if (!patch)
+        return;
+      for (const path of extractPathsFromPatch(patch)) {
+        viewerStore.openToolPreviewTab({
+          path,
+          toolName: "apply_patch",
+          callId,
+          patch,
+          changedLines: getChangedLinesForPath(result, path),
+          status,
+          error: extractErrorMessage2(payload)
+        });
+      }
+    };
+    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;
@@ -2331,6 +2812,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 +2927,7 @@ function useSessionStream(sessionId, enabled = true) {
         if (partIndex === -1) {
           const contentJsonBase = {
             name,
-            _streamedInput: delta
+            _streamedInput: getBoundedStreamingToolInput(delta)
           };
           if (callId)
             contentJsonBase.callId = callId;
@@ -2462,7 +2955,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,
@@ -2750,8 +3243,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 +3255,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,6 +3298,7 @@ function useSessionStream(sessionId, enabled = true) {
           break;
         }
         case "error": {
+          handleToolActivityViewerEvent("error", payload);
           removeEphemeralToolCall(payload);
           const messageId = typeof payload?.messageId === "string" ? payload.messageId : null;
           if (messageId) {
@@ -3022,6 +3523,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 +3671,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 +3927,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 +3950,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();
@@ -5767,6 +6271,7 @@ export {
   useImageUpload,
   useGitStatus,
   useGitRemotes,
+  useGitRebaseAction,
   useGitInit,
   useGitDiffFullFile,
   useGitDiff,
@@ -5797,4 +6302,4 @@ export {
   sessionsQueryKey
 };
 
-//# debugId=AFCFC55375F9489664756E2164756E21
+//# debugId=88EDF96A27BB9BCF64756E2164756E21