{codeViewFiles.length > 0 || (isGitSelection && selectedGitSource?.files?.length) ? (
) : (
diff --git a/apps/web/src/components/GitActionsControl.tsx b/apps/web/src/components/GitActionsControl.tsx
index cae352e6d6b26..a125ceacaed24 100644
--- a/apps/web/src/components/GitActionsControl.tsx
+++ b/apps/web/src/components/GitActionsControl.tsx
@@ -89,7 +89,7 @@ import {
useVcsInitAction,
useVcsPullAction,
} from "../state/sourceControlActions";
-import { useThreadProjection, useQuietThreadShell } from "~/state/entities";
+import { useQuietThreadProjection, useQuietThreadShell } from "~/state/entities";
import { readEnvironmentScope, useEnvironmentScope } from "~/state/session";
import { useEnvironmentQuery } from "~/state/query";
import { serverEnvironment } from "~/state/server";
@@ -958,7 +958,7 @@ export default function GitActionsControl({
? store.getDraftThreadByRef(activeThreadRef)
: null,
);
- const activeServerThreadProjection = useThreadProjection(
+ const activeServerThreadProjection = useQuietThreadProjection(
activeDraftThread !== null && activeServerThreadShell === null ? null : activeThreadRef,
);
const activeServerThread =
diff --git a/apps/web/src/components/HistorySwipeNavigation.test.ts b/apps/web/src/components/HistorySwipeNavigation.test.ts
new file mode 100644
index 0000000000000..9eef35f0dc61e
--- /dev/null
+++ b/apps/web/src/components/HistorySwipeNavigation.test.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vite-plus/test";
+
+import { isMomentumTail } from "./HistorySwipeNavigation";
+
+describe("isMomentumTail", () => {
+ it.each([
+ ["steady momentum decay", [40, 37, 34, 31.3, 28.8], true],
+ ["fingers still moving", [12, 18, 9, 15, 11], false],
+ ["fingers slowing unevenly", [30, 22, 20, 12, 11], false],
+ ["reversing", [10, 8, 6, 4, -2], false],
+ ["too few samples", [40, 37, 34], false],
+ ])("%s", (_name, deltas, expected) => {
+ expect(isMomentumTail(deltas)).toBe(expected);
+ });
+});
diff --git a/apps/web/src/components/HistorySwipeNavigation.tsx b/apps/web/src/components/HistorySwipeNavigation.tsx
new file mode 100644
index 0000000000000..c020878b25363
--- /dev/null
+++ b/apps/web/src/components/HistorySwipeNavigation.tsx
@@ -0,0 +1,189 @@
+import { ArrowLeftIcon, ArrowRightIcon } from "lucide-react";
+import { useEffect, useState } from "react";
+
+import { cn } from "../lib/utils";
+import { canNavigateHistory, navigateHistory, type HistoryDirection } from "../navigationHistory";
+
+const SWIPE_TRIGGER_DISTANCE = 120;
+// Movement needed before the gesture picks an axis; first events are often diagonal.
+const SWIPE_AXIS_LOCK_DISTANCE = 8;
+const MOMENTUM_SAMPLE_SIZE = 5;
+
+type SwipeBounds = { left: number; top: number; width: number; height: number };
+type SwipeGesture =
+ | { kind: "pending"; target: EventTarget | null; y: number; sumX: number; sumY: number }
+ | {
+ kind: "tracking";
+ direction: HistoryDirection;
+ distance: number;
+ deltas: number[];
+ y: number;
+ bounds: SwipeBounds;
+ }
+ // Not a swipe, or one already decided: the rest of its events are ignored.
+ | { kind: "ignored" };
+type SwipeIndicatorState = {
+ direction: HistoryDirection;
+ progress: number;
+ y: number;
+ bounds: SwipeBounds;
+ tracking: boolean;
+};
+
+function readMainContentBounds(): SwipeBounds {
+ const main = document.querySelector('[data-slot="sidebar-inset"]');
+ if (!main) return { left: 0, top: 0, width: window.innerWidth, height: window.innerHeight };
+ const { left, top, width, height } = main.getBoundingClientRect();
+ return { left, top, width, height };
+}
+
+function canScrollHorizontally(target: EventTarget | null, deltaX: number): boolean {
+ for (
+ let element = target instanceof Element ? target : null;
+ element;
+ element = element.parentElement
+ ) {
+ if (element.scrollWidth <= element.clientWidth) continue;
+ const { overflowX } = getComputedStyle(element);
+ if (overflowX !== "auto" && overflowX !== "scroll") continue;
+ const canScroll =
+ deltaX < 0
+ ? element.scrollLeft > 0
+ : element.scrollLeft + element.clientWidth < element.scrollWidth - 1;
+ if (canScroll) return true;
+ }
+ return false;
+}
+
+function lockSwipeAxis(
+ pending: Extract
,
+): Exclude {
+ const { target, sumX, sumY } = pending;
+ if (Math.abs(sumX) <= Math.abs(sumY)) return { kind: "ignored" };
+ if (target instanceof Element && target.closest('[role="dialog"]')) return { kind: "ignored" };
+ if (canScrollHorizontally(target, sumX)) return { kind: "ignored" };
+ const direction = sumX < 0 ? "back" : "forward";
+ if (!canNavigateHistory(direction)) return { kind: "ignored" };
+ return {
+ kind: "tracking",
+ direction,
+ distance: Math.abs(sumX),
+ deltas: [],
+ y: pending.y,
+ bounds: readMainContentBounds(),
+ };
+}
+
+/**
+ * macOS momentum after the fingers lift decays by a near-constant ratio per
+ * event; finger movement is noisier. Deltas are signed along the swipe.
+ */
+export function isMomentumTail(deltas: readonly number[]): boolean {
+ if (deltas.length < MOMENTUM_SAMPLE_SIZE) return false;
+ const recent = deltas.slice(-MOMENTUM_SAMPLE_SIZE);
+ if (recent.some((delta) => delta <= 0)) return false;
+ const ratios = recent.slice(1).map((delta, index) => delta / recent[index]!);
+ return (
+ ratios.every((ratio) => ratio >= 0.7 && ratio < 1) &&
+ Math.max(...ratios) - Math.min(...ratios) < 0.1
+ );
+}
+
+/** Two-finger horizontal trackpad swipes go back and forward, like a browser. */
+export function HistorySwipeNavigation() {
+ const [swipe, setSwipe] = useState(null);
+
+ // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- window wheel and desktop gesture listeners track trackpad swipes
+ useEffect(() => {
+ let gesture: SwipeGesture | null = null;
+ const hideIndicator = () =>
+ setSwipe((current) => (current === null ? null : { ...current, tracking: false }));
+ // The fingers lifted: navigate if the swipe went far enough, then ignore its momentum.
+ const release = () => {
+ if (gesture?.kind === "tracking" && gesture.distance >= SWIPE_TRIGGER_DISTANCE) {
+ navigateHistory(gesture.direction);
+ }
+ gesture = { kind: "ignored" };
+ hideIndicator();
+ };
+ // Chromium brackets each trackpad scroll, momentum included, with these.
+ const unsubscribeScrollBegin = window.desktopBridge?.onTrackpadScrollBegin(() => {
+ if (gesture?.kind === "ignored") gesture = null;
+ });
+ const unsubscribeScrollEnd = window.desktopBridge?.onTrackpadScrollEnd(() => {
+ if (gesture?.kind === "tracking") release();
+ gesture = null;
+ });
+ const onWheel = (event: WheelEvent) => {
+ if (gesture === null) {
+ gesture =
+ event.ctrlKey || event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL
+ ? { kind: "ignored" }
+ : { kind: "pending", target: event.target, y: event.clientY, sumX: 0, sumY: 0 };
+ }
+ if (gesture.kind === "ignored") return;
+ if (gesture.kind === "pending") {
+ gesture.sumX += event.deltaX;
+ gesture.sumY += event.deltaY;
+ if (Math.abs(gesture.sumX) + Math.abs(gesture.sumY) < SWIPE_AXIS_LOCK_DISTANCE) return;
+ gesture = lockSwipeAxis(gesture);
+ if (gesture.kind === "ignored") return;
+ } else {
+ const delta = gesture.direction === "back" ? -event.deltaX : event.deltaX;
+ if (event.deltaX === 0 && event.deltaY === 0) return release();
+ gesture.deltas = [...gesture.deltas.slice(1 - MOMENTUM_SAMPLE_SIZE), delta];
+ if (isMomentumTail(gesture.deltas)) return release();
+ gesture.distance = Math.max(0, gesture.distance + delta);
+ }
+ setSwipe({
+ direction: gesture.direction,
+ progress: Math.min(1, gesture.distance / SWIPE_TRIGGER_DISTANCE),
+ y: gesture.y,
+ bounds: gesture.bounds,
+ tracking: true,
+ });
+ };
+ window.addEventListener("wheel", onWheel, { capture: true, passive: true });
+ return () => {
+ unsubscribeScrollBegin?.();
+ unsubscribeScrollEnd?.();
+ window.removeEventListener("wheel", onWheel, { capture: true });
+ };
+ }, []);
+
+ return swipe === null ? null : ;
+}
+
+// A circle pinned to the edge of the main content that peeks in up to half its width.
+function SwipeIndicator({ direction, progress, y, bounds, tracking }: SwipeIndicatorState) {
+ const armed = progress >= 1;
+ const Icon = direction === "back" ? ArrowLeftIcon : ArrowRightIcon;
+ const hidden = 100 - progress * 50;
+ return (
+
+ );
+}
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index b9c5a0f21de95..c62349473a704 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -1111,6 +1111,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps)
const composerSendState = deriveComposerSendState({
prompt,
imageCount: composerImages.length + composerFiles.length,
+ existingAttachmentCount: editingQueuedAttachments?.length ?? 0,
terminalContexts: composerTerminalContexts,
elementContextCount: composerPreviewAnnotations.length + composerReviewComments.length,
});
diff --git a/apps/web/src/components/chat/MessagesTimeline.browser.test.tsx b/apps/web/src/components/chat/MessagesTimeline.browser.test.tsx
index 2c7aa332756cb..24e15957192b1 100644
--- a/apps/web/src/components/chat/MessagesTimeline.browser.test.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.browser.test.tsx
@@ -3,6 +3,7 @@ import { onTestFinished } from "vite-plus/test";
import { page } from "vite-plus/test/browser";
import { stubGlobal } from "../../../test/render";
import {
+ ComposerContextId,
EnvironmentId,
MessageId,
RunAttemptId,
@@ -32,6 +33,11 @@ import { toastManager } from "../ui/toast";
import type { CitedHistory } from "./citationProcedure";
import type { TimelineNavigation } from "./timelineViewport";
import { rememberTimelinePosition } from "./timelineScrollAnchoring";
+import {
+ COMPOSER_CONTEXT_CLIPBOARD_MIME,
+ decodeComposerContextFragment,
+} from "@t3tools/shared/composerContextClipboard";
+import { collectComposerContextReferences } from "@t3tools/shared/composerContextReferences";
const environmentQuery = vi.hoisted(() => ({
error: "Pull request not found",
@@ -642,6 +648,75 @@ describe("MessagesTimeline agent messages", () => {
});
describe("MessagesTimeline attachments", () => {
+ it.each(["image", "file"] as const)(
+ "copies only matching context records for a wordless %s attachment",
+ async (kind) => {
+ const attachment = {
+ type: kind,
+ id: "media",
+ name: kind === "image" ? "photo.png" : "clip.mp4",
+ mimeType: kind === "image" ? "image/png" : "video/mp4",
+ sizeBytes: 100,
+ downloadable: false,
+ };
+ const record = {
+ version: 1 as const,
+ ...(kind === "image" ? { kind: "image" as const } : { kind: "file" as const }),
+ contextId: ComposerContextId.make("media-context"),
+ label: attachment.name,
+ attachmentId: attachment.id,
+ name: attachment.name,
+ mimeType: attachment.mimeType,
+ sizeBytes: attachment.sizeBytes,
+ };
+ await using screen = await renderTimeline([message("", { attachments: [attachment] })]);
+ expect(screen.buttons("Copy message")).toHaveLength(0);
+ await screen.rerender(
+ ,
+ );
+ expect(screen.buttons("Copy message")).toHaveLength(0);
+ await screen.rerender(
+ ,
+ );
+ using write = vi.spyOn(navigator.clipboard, "write").mockResolvedValue();
+ await click(screen.button("Copy message"));
+ await vi.waitFor(() => expect(write).toHaveBeenCalledOnce());
+ const [item] = write.mock.calls[0]![0];
+ const text = await (await item!.getType("text/plain")).text();
+ const fragment = await (await item!.getType(COMPOSER_CONTEXT_CLIPBOARD_MIME)).text();
+ expect(
+ collectComposerContextReferences(text).map((reference) => reference.contextId),
+ ).toEqual([record.contextId]);
+ expect(decodeComposerContextFragment(fragment)?.records).toEqual([record]);
+ },
+ );
+
it.each(["loadedmetadata", "loadeddata", "canplay"])(
"plays audio with unknown duration after %s and updates the total later",
async (readyEvent) => {
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index bd74694dc46af..c9aec993bcd86 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -1390,6 +1390,74 @@ describe("deriveMessagesTimelineRows", () => {
]);
});
+ it("stacks back-to-back steers as one burst with a single steer label", () => {
+ const runId = RunId.make("double-steer-run");
+ const time = (second: number) => new Date(Date.UTC(2026, 0, 1, 0, 0, second)).toISOString();
+ const message = (
+ id: string,
+ second: number,
+ role: "user" | "assistant",
+ inputIntent?: "turn_start" | "steer",
+ ): TimelineEntry => ({
+ kind: "message",
+ id,
+ createdAt: time(second),
+ message: {
+ id: MessageId.make(id),
+ role,
+ text: id,
+ runId,
+ ...(inputIntent ? { inputIntent } : {}),
+ createdAt: time(second),
+ updatedAt: time(second),
+ streaming: false,
+ },
+ });
+ const prompt = message("prompt", 0, "user", "turn_start");
+ const work: TimelineEntry = {
+ kind: "work",
+ id: "work",
+ createdAt: time(4),
+ entry: { id: "work", createdAt: time(4), runId, label: "Ran command", tone: "tool" },
+ };
+ const firstSteer = message("first-steer", 10, "user", "steer");
+ const deriveRows = (timelineEntries: TimelineEntry[]) =>
+ deriveMessagesTimelineRows({
+ timelineEntries,
+ latestRun: { runId, status: "completed", startedAt: time(0), completedAt: time(30) },
+ isWorking: false,
+ expandedRunIds: new Set(),
+ turnDiffSummaries: [],
+ supportsConversationRollback: false,
+ });
+ // The second steer arrives while the first message object is reused, as live updates do.
+ const before = computeStableMessagesTimelineRows(deriveRows([prompt, work, firstSteer]), {
+ result: [],
+ byId: new Map(),
+ });
+ const rows = computeStableMessagesTimelineRows(
+ deriveRows([
+ prompt,
+ work,
+ firstSteer,
+ message("second-steer", 12, "user", "steer"),
+ message("final", 30, "assistant"),
+ ]),
+ before,
+ ).result;
+
+ const byId = new Map(rows.map((row) => [row.id, row]));
+ expect(byId.get("prompt")).not.toHaveProperty("groupedWithNext");
+ expect(byId.get("first-steer")).toMatchObject({
+ groupedWithNext: true,
+ continuesSteer: false,
+ });
+ expect(byId.get("second-steer")).toMatchObject({
+ groupedWithNext: false,
+ continuesSteer: true,
+ });
+ });
+
it("keeps the previous turn folded while a newly sent message awaits its turn", () => {
const rows = deriveMessagesTimelineRows({
timelineEntries: [
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index c26bcf51a718a..1f22bc1c14978 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -1,4 +1,5 @@
import { worktreeSetupAgentStarted } from "@t3tools/client-runtime/worktree-setup";
+import { resolveUserMessagePresentation } from "@t3tools/client-runtime/user-message";
import { isLiveSubagentTurnItem } from "@t3tools/client-runtime/state/subagentRuntime";
import * as DateTime from "effect/DateTime";
import * as Equal from "effect/Equal";
@@ -594,6 +595,10 @@ type MessagesTimelineRowContent =
assistantCopyStreaming: boolean;
assistantTurnDiffSummary?: TurnDiffSummary | undefined;
revertTurnCount?: number | undefined;
+ /** Another of your messages follows directly, so the two sit closer together. */
+ groupedWithNext?: boolean;
+ /** Set when the message above is a steer too, so the label shows once. */
+ continuesSteer?: boolean;
}
| {
kind: "assistant-meta";
@@ -2134,13 +2139,36 @@ export function deriveMessagesTimelineRows(input: {
const result = attachTrailingToolGroupsToAssistant(
attachCreatedThreadSummaries(nextRows, timelineEntries, collapsedFoldMemberIds),
);
- return result.map((row, index) =>
- timelineRowIsWorkLog(row) && timelineRowIsWorkLog(result[index + 1])
- ? { ...row, continuesWorkLog: true }
- : row,
+ return result.map((row, index) => {
+ if (timelineRowIsWorkLog(row) && timelineRowIsWorkLog(result[index + 1])) {
+ return { ...row, continuesWorkLog: true };
+ }
+ if (!timelineRowIsOwnUserMessage(row)) return row;
+ const previous = result[index - 1];
+ const groupedWithNext = timelineRowIsOwnUserMessage(result[index + 1]);
+ const continuesSteer =
+ timelineRowIsOwnUserMessage(previous) &&
+ messageIsSteer(row.message) &&
+ messageIsSteer(previous.message);
+ if (!groupedWithNext && !continuesSteer) return row;
+ return { ...row, groupedWithNext, continuesSteer };
+ });
+}
+
+function timelineRowIsOwnUserMessage(
+ row: MessagesTimelineRow | undefined,
+): row is Extract {
+ return (
+ row?.kind === "message" &&
+ row.message.role === "user" &&
+ resolveUserMessagePresentation(row.message).attribution === null
);
}
+function messageIsSteer(message: ChatMessage): boolean {
+ return message.inputIntent === "steer" || message.inputIntent === "promoted_queued_to_steer";
+}
+
function timelineRowIsWorkLog(row: MessagesTimelineRow | undefined): boolean {
return (
row !== undefined &&
@@ -2478,7 +2506,9 @@ function isRowUnchanged(a: MessagesTimelineRow, b: MessagesTimelineRow): boolean
a.showAssistantCopyButton === bm.showAssistantCopyButton &&
a.assistantCopyStreaming === bm.assistantCopyStreaming &&
a.assistantTurnDiffSummary === bm.assistantTurnDiffSummary &&
- a.revertTurnCount === bm.revertTurnCount
+ a.revertTurnCount === bm.revertTurnCount &&
+ a.groupedWithNext === bm.groupedWithNext &&
+ a.continuesSteer === bm.continuesSteer
);
}
}
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index ee967cfbacb37..842165d37a22f 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -660,12 +660,11 @@ const ConversationTimeline = memo(function ConversationTimeline({
? new Set(paintedExpandedAttemptIds).add(activeFindAttemptId)
: paintedExpandedAttemptIds;
- const pendingApprovalsByRequestId = new Map(
- pendingApprovals
- .filter((approval) => !heldApprovalRequestIds?.has(approval.requestId))
- .map((approval) => [approval.requestId, approval]),
+ const isVisiblePendingApproval = (approval: PendingApproval) =>
+ !heldApprovalRequestIds?.has(approval.requestId);
+ const pendingApprovalRequestIds = new Set(
+ pendingApprovals.filter(isVisiblePendingApproval).map((approval) => approval.requestId),
);
- const pendingApprovalRequestIds = new Set(pendingApprovalsByRequestId.keys());
const rawRows = useIncrementalTimelineRows(`${listIdentityKey}\0${workspaceRoot ?? ""}`, {
timelineEntries,
pendingApprovalRequestIds,
@@ -684,17 +683,19 @@ const ConversationTimeline = memo(function ConversationTimeline({
worktreeSetup,
});
const rows = useStableRows(rawRows, listIdentityKey);
- const unmatchedPendingApprovals = new Map(pendingApprovalsByRequestId);
- if (unmatchedPendingApprovals.size > 0) {
- for (const row of rows) {
- const entries =
- row.kind === "work" ? row.groupedEntries : row.kind === "work-live" ? [row.entry] : [];
- for (const entry of entries) {
- const item = entry.projectedItem?.item;
- if (item?.type === "approval_request") unmatchedPendingApprovals.delete(item.requestId);
- }
+ const matchedApprovalRequestIds = new Set();
+ for (const row of pendingApprovalRequestIds.size > 0 ? rows : []) {
+ const entries =
+ row.kind === "work" ? row.groupedEntries : row.kind === "work-live" ? [row.entry] : [];
+ for (const entry of entries) {
+ const item = entry.projectedItem?.item;
+ if (item?.type === "approval_request") matchedApprovalRequestIds.add(item.requestId);
}
}
+ const unmatchedPendingApprovals = pendingApprovals.filter(
+ (approval) =>
+ isVisiblePendingApproval(approval) && !matchedApprovalRequestIds.has(approval.requestId),
+ );
// Run status/timestamps change per stream event; keep them out of shared row context.
const runs = useStableHandoffRuns(runsProp);
const minimapItems = deriveTimelineMinimapItems(rows);
@@ -707,7 +708,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
restoringThreadPosition && restoreRowIndex >= 0 ? { indices: [restoreRowIndex] } : undefined;
const showsEmptyState =
rows.length === 0 &&
- unmatchedPendingApprovals.size === 0 &&
+ unmatchedPendingApprovals.length === 0 &&
!isWorking &&
parentThreadLink === null &&
historyControls === undefined &&
@@ -1001,6 +1002,13 @@ const ConversationTimeline = memo(function ConversationTimeline({
};
};
+ // Built from props after the last hook so the compiler can memoize the row context; a map
+ // made before a hook would rebuild it, and re-render every row, on each streamed update.
+ const pendingApprovalsByRequestId = new Map(
+ pendingApprovals
+ .filter(isVisiblePendingApproval)
+ .map((approval) => [approval.requestId, approval]),
+ );
const sharedState: TimelineRowSharedState = {
pendingApprovals: pendingApprovalsByRequestId,
respondingRequestIds,
@@ -1239,12 +1247,12 @@ const ConversationTimeline = memo(function ConversationTimeline({
onGrow={onFooterGrow}
>
{footer}
- {unmatchedPendingApprovals.size > 0 ? (
+ {unmatchedPendingApprovals.length > 0 ? (
- {[...unmatchedPendingApprovals.values()].map((approval) => (
+ {unmatchedPendingApprovals.map((approval) => (
))}
@@ -1435,16 +1443,18 @@ const TimelineRowContent = memo(function TimelineRowContent({ row }: { row: Time
? undefined
: row.kind === "turn-fold" || row.kind === "working"
? "pb-1.5"
- : (row.kind === "message" &&
- row.message.role === "assistant" &&
- !row.showAssistantMeta) ||
- row.kind === "worktree-setup" ||
- row.kind === "event" ||
- row.kind === "attempt-fold" ||
- row.kind === "html-render" ||
- row.kind === "mcp-app"
- ? "pb-2"
- : "pb-4",
+ : row.kind === "message" && row.groupedWithNext
+ ? "pb-1"
+ : (row.kind === "message" &&
+ row.message.role === "assistant" &&
+ !row.showAssistantMeta) ||
+ row.kind === "worktree-setup" ||
+ row.kind === "event" ||
+ row.kind === "attempt-fold" ||
+ row.kind === "html-render" ||
+ row.kind === "mcp-app"
+ ? "pb-2"
+ : "pb-4",
(row.kind === "message" && row.message.role === "assistant") ||
row.kind === "assistant-meta"
? "group/assistant"
diff --git a/apps/web/src/components/chat/ThreadTimeline.tsx b/apps/web/src/components/chat/ThreadTimeline.tsx
index 7d1db86178cf4..a68d494d8b0a0 100644
--- a/apps/web/src/components/chat/ThreadTimeline.tsx
+++ b/apps/web/src/components/chat/ThreadTimeline.tsx
@@ -2,7 +2,7 @@ import type { ScopedThreadRef } from "@t3tools/contracts";
import { type ComponentProps, useLayoutEffect } from "react";
import { useIncrementalTimelineEntries } from "../../hooks/useIncrementalTimelineEntries";
import type { TimelineEntriesInput, TimelineEntry } from "../../session-logic";
-import { useThreadVisibleTurnItems } from "../../state/entities";
+import { useTimelineVisibleTurnItems } from "../../state/entities";
import {
peekRememberedThreadTimeline,
rememberReadyThreadTimeline,
@@ -14,7 +14,8 @@ import { MessagesTimeline } from "./MessagesTimeline";
/**
* The timeline with the streamed text. ChatView reads the thread through its quiet
* atoms, which hold through text deltas; this reads the live turn items, so a
- * delta re-renders the timeline without re-rendering ChatView.
+ * reasoning delta re-renders the timeline without re-rendering ChatView. Streamed
+ * assistant text reaches only its own row, through useAssistantMessageText.
*/
export function ThreadTimeline({
threadDetailRef,
@@ -34,7 +35,7 @@ export function ThreadTimeline({
syncing: boolean;
detailLoading: boolean;
}) {
- const visibleTurnItems = useThreadVisibleTurnItems(threadDetailRef);
+ const visibleTurnItems = useTimelineVisibleTurnItems(threadDetailRef);
const serverEntries = useIncrementalTimelineEntries(activeThreadKey, {
...entriesInput,
visibleTurnItems,
diff --git a/apps/web/src/components/chat/TimelineAssistantRows.tsx b/apps/web/src/components/chat/TimelineAssistantRows.tsx
index e9be291be750f..714904e15bca2 100644
--- a/apps/web/src/components/chat/TimelineAssistantRows.tsx
+++ b/apps/web/src/components/chat/TimelineAssistantRows.tsx
@@ -12,7 +12,7 @@ import { McpAppFrame } from "./McpAppFrame";
import { checkpointFileTotals } from "@t3tools/client-runtime/state/thread-checkpoints";
import { ChangedFilesCard } from "./ChangedFilesTree";
import { useFileContextMenuHandler } from "../../fileContextMenu";
-import { useProject, useThreadShell } from "../../state/entities";
+import { useAssistantMessageText, useProject, useThreadShell } from "../../state/entities";
import { MessageCopyButton } from "./MessageCopyButton";
import { AssistantCitationSource } from "./AssistantCitationSource";
import { resolveAssistantMessageCopyState } from "./MessagesTimeline.logic";
@@ -26,7 +26,13 @@ import { MESSAGE_HEADING_LEVEL, MessageAuthorHeading } from "./TimelineRowParts"
export function AssistantTimelineRow({ row }: { row: Extract
}) {
const ctx = use(TimelineRowCtx);
- const messageText = row.message.text || (row.message.streaming ? "" : "(empty response)");
+ // The timeline holds a streaming message's row while only its text grows.
+ const liveText = useAssistantMessageText(
+ row.message.streaming ? ctx.threadRef : null,
+ row.projectedItem?.item.id,
+ );
+ const text = liveText ?? row.message.text;
+ const messageText = text || (row.message.streaming ? "" : "(empty response)");
return (
<>
diff --git a/apps/web/src/components/chat/TimelineUserMessageRow.logic.ts b/apps/web/src/components/chat/TimelineUserMessageRow.logic.ts
index 9738e29d7ccaa..2bb6d0470fa18 100644
--- a/apps/web/src/components/chat/TimelineUserMessageRow.logic.ts
+++ b/apps/web/src/components/chat/TimelineUserMessageRow.logic.ts
@@ -1,7 +1,11 @@
-import { type ChatImageAttachment } from "../../types";
+import { type ChatFileAttachment, type ChatImageAttachment } from "../../types";
import type { ComposerContextRecord, KnownComposerContextRecord } from "@t3tools/contracts";
import { asKnownContextRecord } from "~/lib/composerContextRecords";
+export function userMessageFileLabel(file: Pick) {
+ return file.source?._tag === "pasted-text" ? "Pasted text" : file.name;
+}
+
export function resolvePreviewAnnotationImage(input: {
record: Extract;
recordsById: ReadonlyMap;
diff --git a/apps/web/src/components/chat/TimelineUserMessageRow.tsx b/apps/web/src/components/chat/TimelineUserMessageRow.tsx
index fba369fb1d497..6278b03859618 100644
--- a/apps/web/src/components/chat/TimelineUserMessageRow.tsx
+++ b/apps/web/src/components/chat/TimelineUserMessageRow.tsx
@@ -54,6 +54,7 @@ import { GuestMessageName, guestBubbleClassName } from "./guestMessageStyle";
import { MessageCopyButton } from "./MessageCopyButton";
import { promptLinkFor } from "../promptLinks/copyPromptLink";
import { PierreEntryIcon } from "./PierreEntryIcon";
+import { formatBytes } from "../../lib/formatBytes";
import { shouldCollapseUserMessage } from "./MessagesTimeline.logic";
import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
import {
@@ -61,7 +62,10 @@ import {
resolveUserMessageContext,
selectedMessageContextFragment,
} from "~/lib/composerContextRecords";
-import { collectComposerContextReferences } from "@t3tools/shared/composerContextReferences";
+import {
+ collectComposerContextReferences,
+ formatComposerContextReference,
+} from "@t3tools/shared/composerContextReferences";
import {
COMPOSER_CONTEXT_CLIPBOARD_MIME,
encodeComposerContextClipboardHtml,
@@ -79,7 +83,10 @@ import {
TimelineRowTimestamp,
} from "./TimelineRowParts";
import { UserMessageContextReferenceChip } from "./UserMessageContextChips";
-import { resolvePreviewAnnotationImage } from "./TimelineUserMessageRow.logic";
+import {
+ resolvePreviewAnnotationImage,
+ userMessageFileLabel,
+} from "./TimelineUserMessageRow.logic";
// Drawn inside the media so dark screenshots keep an edge on the dark background.
const MEDIA_EDGE_CLASS_NAME =
@@ -88,7 +95,89 @@ const MEDIA_EDGE_CLASS_NAME =
const BUBBLE_CHIP_CLASS_NAME =
"[&_[data-slot=context-chip]]:[--context-chip-ink:var(--context-chip-message,var(--context-chip-accent))]";
-function UserVideoAttachment({ file }: { readonly file: ChatFileAttachment }) {
+function UserFileCard({
+ file,
+ copyMarkdown,
+}: {
+ readonly file: ChatFileAttachment;
+ readonly copyMarkdown: string | undefined;
+}) {
+ const ctx = use(TimelineRowCtx);
+ const pastedText = file.source?._tag === "pasted-text";
+ const label = userMessageFileLabel(file);
+ const extension = /\.([a-z0-9]{1,8})$/i.exec(file.name)?.[1]?.toUpperCase() ?? "File";
+ const identity = (
+ <>
+
+
+
+
+
+ {label}
+
+
+ {file.downloadable === false ? (
+ "Sending…"
+ ) : (
+ <>
+ {!pastedText && `${extension} · `}
+ {formatBytes(file.sizeBytes)}
+
+ )}
+
+
+
+ );
+ return (
+
+ {file.downloadable === false ? (
+ <>
+
{identity}
+
+
+ ) : (
+ <>
+
+
+ ctx.onFileDownload(file)}
+ />
+ }
+ >
+
+
+ Download {label}
+
+
+ )}
+
+
{file.name}
);
}
- return (
+ const player = (
);
+ return standalone ? (
+
{player}
+ ) : (
+ player
+ );
}
export function UserMessageRow({ row }: { row: Extract
}) {
@@ -334,11 +441,22 @@ function UserTimelineRow({ row }: { row: Extract image.name.startsWith("preview-annotation-"));
const revertTurnCount = row.revertTurnCount;
- const chippedAttachmentIds = new Set(
- collectComposerContextReferences(resolvedContext.text).flatMap((occurrence) => {
+ const attachmentReferences = collectComposerContextReferences(resolvedContext.text).flatMap(
+ (occurrence) => {
const record = asKnownContextRecord(resolvedContext.recordsById.get(occurrence.contextId));
- return record?.kind === "file" || record?.kind === "image" ? [record.attachmentId] : [];
- }),
+ return record?.kind === "file" || record?.kind === "image"
+ ? [
+ {
+ attachmentId: record.attachmentId,
+ contextId: occurrence.contextId,
+ source: occurrence.source,
+ },
+ ]
+ : [];
+ },
+ );
+ const chippedAttachmentIds = new Set(
+ attachmentReferences.map((reference) => reference.attachmentId),
);
const regularImages = userImages.filter((image) => !image.name.startsWith("preview-annotation-"));
const unchippedFiles = otherUserFiles.filter((file) => !chippedAttachmentIds.has(file.id));
@@ -351,18 +469,51 @@ function UserTimelineRow({ row }: { row: Extract 0;
+ // Media sent with words sits above the bubble as its own shape, like a chat app.
+ const mediaAboveText =
+ !folded &&
+ userMessage.attribution !== "guest" &&
+ !mediaOnly &&
+ regularImages.length + userVideos.length > 0;
+ const standaloneMedia = mediaOnly || mediaAboveText;
// A lone image keeps its own shape; a 4:3 crop hides most of a wide screenshot.
- const loneImage =
- mediaOnly &&
- userVideos.length === 0 &&
- regularImages.length === 1 &&
- regularImages[0]!.source?.kind !== "snap-shot";
- // Several images sent without words share one rounded shape, split by hairlines.
+ const loneImage = standaloneMedia && userVideos.length === 0 && regularImages.length === 1;
+ // Several images share one rounded shape, split by hairlines.
const collage =
- mediaOnly &&
+ standaloneMedia &&
userVideos.length === 0 &&
regularImages.length > 1 &&
regularImages.every((image) => image.source?.kind !== "snap-shot");
+ // Files sent without words show as cards, not as a bubble around a name chip.
+ const fileCardsOnly =
+ !folded &&
+ userMessage.attribution !== "guest" &&
+ otherUserFiles.length > 0 &&
+ regularImages.length + userVideos.length + userAudio.length + unknownAttachments.length === 0 &&
+ replaceComposerContextReferences(resolvedContext.text, (reference) =>
+ attachmentReferences.some(
+ (attached) =>
+ attached.contextId === reference.contextId &&
+ otherUserFiles.some((file) => file.id === attached.attachmentId),
+ )
+ ? ""
+ : reference.label,
+ ).trim() === "";
+ const audioOnly =
+ !folded &&
+ userMessage.attribution !== "guest" &&
+ userAudio.length > 0 &&
+ regularImages.length + userVideos.length + otherUserFiles.length + unknownAttachments.length ===
+ 0 &&
+ replaceComposerContextReferences(resolvedContext.text, (reference) =>
+ attachmentReferences.some(
+ (attached) =>
+ attached.contextId === reference.contextId &&
+ userAudio.some((file) => file.id === attached.attachmentId),
+ )
+ ? ""
+ : reference.label,
+ ).trim() === "";
const annotationRecordIds = resolvedContext.records
.filter((record) => record.kind === "preview-annotation")
.map((record) => record.contextId);
@@ -376,8 +527,19 @@ function UserTimelineRow({ row }: { row: Extract line.trim().length > 0)
?.trim() ?? "";
+ const mediaCopyRecords = mediaOnly
+ ? resolvedContext.records.flatMap((record) => {
+ const known = asKnownContextRecord(record);
+ return (known?.kind === "image" || known?.kind === "file") &&
+ (regularImages.some((image) => image.id === known.attachmentId) ||
+ userVideos.some((file) => file.id === known.attachmentId))
+ ? [known]
+ : [];
+ })
+ : [];
+ const copyRecords = mediaOnly ? mediaCopyRecords : resolvedContext.records;
const contextClipboardFragment =
- resolvedContext.records.length === 0
+ copyRecords.length === 0
? null
: encodeComposerContextFragment({
version: 1,
@@ -386,8 +548,10 @@ function UserTimelineRow({ row }: { row: Extract) => {
if (resolvedContext.records.length === 0 || !event.clipboardData) return;
const selection = window.getSelection();
@@ -465,6 +629,112 @@ function UserTimelineRow({ row }: { row: Extract 0 || userVideos.length > 0 ? (
+
+ {regularImages.map((image, index) => (
+
3 &&
+ regularImages.length % 2 === 1 &&
+ index === regularImages.length - 1 &&
+ "col-span-2",
+ )
+ : standaloneMedia
+ ? cn(MEDIA_EDGE_CLASS_NAME, "aspect-[4/3] overflow-hidden rounded-2xl")
+ : "aspect-[4/3] overflow-hidden rounded-lg border border-border/80",
+ )}
+ >
+ {image.previewUrl ? (
+
+ ) : (
+
+ {image.name}
+
+ )}
+ {image.previewUrl && image.source?.kind === "snap-shot" ? (
+
+ ) : null}
+
+ ))}
+ {userVideos.map((file) => (
+
+ ))}
+
+ {/* The heading leads the media so screen readers reach it before the images. */}
+ You
+ {mediaBlock}
+
+ ) : null}
{/* Outside the fold so a collapsed message still has a heading to navigate to. */}
-
- {folded
- ? senderLabel
- : userMessage.guestName === undefined
- ? "You"
- : `${userMessage.guestName} (guest)`}
-
+ {mediaAboveText ? null : (
+
+ {folded
+ ? senderLabel
+ : userMessage.guestName === undefined
+ ? "You"
+ : `${userMessage.guestName} (guest)`}
+
+ )}
{folded ? (
- {(regularImages.length > 0 || userVideos.length > 0) && (
-
- {regularImages.map((image, index) => (
-
3 &&
- regularImages.length % 2 === 1 &&
- index === regularImages.length - 1 &&
- "col-span-2",
- )
- : "aspect-[4/3] overflow-hidden rounded-lg border border-border/80",
- )}
- >
- {image.previewUrl ? (
-
- ) : (
-
- {image.name}
-
- )}
- {image.previewUrl && image.source?.kind === "snap-shot" ? (
-
- ) : null}
-
- ))}
- {userVideos.map((file) => (
-
- ))}
-
+
{userAudio.map((file) => (
) : null}
- {unchippedFiles.length > 0 || unknownAttachments.length > 0 ? (
+ {fileCardsOnly ? (
+
+ {otherUserFiles.map((file) => (
+ reference.attachmentId === file.id)
+ ?.source
+ }
+ />
+ ))}
+
+ ) : null}
+ {!fileCardsOnly && (unchippedFiles.length > 0 || unknownAttachments.length > 0) ? (
{unchippedFiles.map((file) => {
+ const pastedText = file.source?._tag === "pasted-text";
+ const label = userMessageFileLabel(file);
const fileIdentity = (
<>
-
{file.name}
+
+ {label}
+ {file.downloadable === false || pastedText ? (
+
+ {file.downloadable === false ? "Sending…" : formatBytes(file.sizeBytes)}
+
+ ) : null}
+
);
if (file.downloadable !== false) {
@@ -655,7 +873,7 @@ function UserTimelineRow({ row }: { row: Extract
-
-
+ {fileCardsOnly || audioOnly ? null : (
+
+
+
+ )}
) : null}
More
\n\nHidden bold \n\n
| [x](#frag) |\n\n- [ ] task\n- [x] done",
+ '```ts title="a.ts"\nconst a = 1;\n```\n\n> [!WARNING]\n> careful bare',
+ "Footnote[^1] and ~~strike~~\n\n[^1]: the note",
+ // Each GFM construct the parser skips when its text cannot match, next to one that can.
+ "Mail me@example.com, see www.example.com and HTTPS://example.com/a, not [x](https://y.z).",
+ "a.b-c_d+e@x.io and @user\n\n`me@x.io` ",
+ "A table without pipes\n:--",
+ "> | quoted |\n> | - |\n> | body |\n\n- [ ] open\n- [X] done",
+ "Escaped www\\.example.com and me@example.com",
+ "\ufeffA byte order mark\n\n| a |\n| - |\n| b |",
+ "> - | a |\r\n> | - |\r\n> | me@x.io |\r\n\n-\t[ ] tab\n\n ~~lazy~~",
+ ])("renders what react-markdown renders: %j", (source) => {
+ const expected = renderToStaticMarkup(
+
+ {source}
+ ,
+ );
+ const element = render(source, true);
+ expect(renderToStaticMarkup(element)).toBe(expected);
+ expect(render(source, true)).toBe(element);
+ });
+
+ it("renders what react-markdown renders while a reply streams through the incremental parser", () => {
+ const reply =
+ "```ts\nconst a = 1;\n```\n\n| a | b |\n| - | - |\n| me@x.io | www.x.io |\n\nDone ~~now~~.";
+ // As ChatMarkdown streams: one incremental plugin for the reply, a fresh renderer per update.
+ const incremental = createIncrementalMarkdownPlugin();
+ for (let end = 1; end <= reply.length; end++) {
+ const source = reply.slice(0, end);
+ const streamed = createMarkdownRenderer({
+ remarkPlugins: [...CHAT_MARKDOWN_REMARK_PLUGINS, incremental],
+ rehypePlugins: CHAT_MARKDOWN_REHYPE_PLUGINS,
+ components: {},
+ urlTransform,
+ })(source, false);
+ expect(renderToStaticMarkup(streamed)).toBe(
+ renderToStaticMarkup(
+
+ {source}
+ ,
+ ),
+ );
+ }
+ });
+
+ it("keeps cached messages when one far larger than the cache is rendered", () => {
+ const element = render("Kept *message*", true);
+ render("x".repeat(600_000), true);
+ expect(render("Kept *message*", true)).toBe(element);
+ });
+});
diff --git a/apps/web/src/components/chat/markdownRenderer.ts b/apps/web/src/components/chat/markdownRenderer.ts
new file mode 100644
index 0000000000000..ab4083f2adf47
--- /dev/null
+++ b/apps/web/src/components/chat/markdownRenderer.ts
@@ -0,0 +1,109 @@
+import type { Element, Nodes, Root } from "hast";
+import { toJsxRuntime, type Components } from "hast-util-to-jsx-runtime";
+import { urlAttributes } from "html-url-attributes";
+import type { ReactElement } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { type PluggableList, unified } from "unified";
+import { VFile } from "vfile";
+
+import { remarkParseWithoutUnusedSyntax } from "./markdownSyntaxGates";
+
+export type MarkdownUrlTransform = (url: string, key: string, node: Element) => string;
+
+interface MarkdownRendererOptions {
+ readonly remarkPlugins: PluggableList;
+ readonly rehypePlugins: PluggableList;
+ readonly components: Partial;
+ readonly urlTransform: MarkdownUrlTransform;
+}
+
+// Elements are immutable, so a remount (a thread switch, a row scrolled back into view)
+// reuses one instead of parsing again. Parsing is most of the cost of rendering markdown.
+// An element and the hast it keeps hold about 20 bytes per source character, so ~10 MB.
+const MAX_CACHED_CHARS = 500_000;
+const rendered = new Map();
+let cachedChars = 0;
+let nextRendererId = 0;
+
+// A short block still holds a whole element tree.
+const ENTRY_OVERHEAD_CHARS = 200;
+const entrySize = (key: string) => key.length + ENTRY_OVERHEAD_CHARS;
+
+function remember(key: string, element: ReactElement) {
+ // One huge message would otherwise evict everything else.
+ if (entrySize(key) > MAX_CACHED_CHARS / 4) return;
+ rendered.set(key, element);
+ cachedChars += entrySize(key);
+ for (const oldest of rendered.keys()) {
+ if (cachedChars <= MAX_CACHED_CHARS) break;
+ rendered.delete(oldest);
+ cachedChars -= entrySize(oldest);
+ }
+}
+
+/** Renders markdown as react-markdown does, with one processor per plugin set. */
+export function createMarkdownRenderer({
+ remarkPlugins,
+ rehypePlugins,
+ components,
+ urlTransform,
+}: MarkdownRendererOptions) {
+ const processor = unified()
+ .use(remarkParse)
+ .use(remarkParseWithoutUnusedSyntax)
+ .use(remarkPlugins)
+ .use(remarkRehype, { allowDangerousHtml: true })
+ .use(rehypePlugins)
+ .freeze();
+ const keyPrefix = `${nextRendererId++}\u0000`;
+
+ // Literal raw HTML that survived the rehype plugins, and URL attributes, as react-markdown treats them.
+ const prepare = (node: Nodes) => {
+ if (!("children" in node)) return;
+ const { children } = node;
+ for (let index = 0; index < children.length; index++) {
+ const child = children[index]!;
+ if (child.type === "raw") {
+ children[index] = { type: "text", value: child.value };
+ continue;
+ }
+ if (child.type !== "element") continue;
+ const { properties } = child;
+ for (const key in properties) {
+ if (!Object.hasOwn(urlAttributes, key)) continue;
+ const tags = urlAttributes[key];
+ if (tags === null || tags?.includes(child.tagName)) {
+ properties[key] = urlTransform(String(properties[key] || ""), key, child);
+ }
+ }
+ prepare(child);
+ }
+ };
+
+ return (text: string, cache: boolean): ReactElement => {
+ const key = keyPrefix + text;
+ const cached = rendered.get(key);
+ if (cached !== undefined) {
+ // Refresh its place in the eviction order.
+ rendered.delete(key);
+ rendered.set(key, cached);
+ return cached;
+ }
+ const file = new VFile(text);
+ const tree = processor.runSync(processor.parse(file), file) as Root;
+ prepare(tree);
+ const element = toJsxRuntime(tree, {
+ Fragment,
+ components,
+ ignoreInvalidStyle: true,
+ jsx,
+ jsxs,
+ passKeys: true,
+ passNode: true,
+ });
+ if (cache) remember(key, element);
+ return element;
+ };
+}
diff --git a/apps/web/src/components/chat/markdownStreamBlocks.test.tsx b/apps/web/src/components/chat/markdownStreamBlocks.test.tsx
new file mode 100644
index 0000000000000..ae81316580bbd
--- /dev/null
+++ b/apps/web/src/components/chat/markdownStreamBlocks.test.tsx
@@ -0,0 +1,61 @@
+import {
+ CHAT_MARKDOWN_REHYPE_PLUGINS,
+ CHAT_MARKDOWN_REMARK_PLUGINS,
+} from "@t3tools/shared/markdownPipeline";
+import { renderToStaticMarkup } from "react-dom/server";
+import ReactMarkdown from "react-markdown";
+import { describe, expect, it } from "vite-plus/test";
+
+import { splitMarkdownBlocks } from "./markdownStreamBlocks";
+
+// Whitespace between top-level blocks collapses in the rendered message.
+const html = (source: string) =>
+ renderToStaticMarkup(
+
+ {source}
+ ,
+ )
+ .replace(/>\s+<")
+ .trim();
+
+describe("splitMarkdownBlocks", () => {
+ it.each([
+ "# Title\n\nFirst paragraph with `code` and **bold**.\n\nSecond [link](https://example.com).",
+ "- one\n- two\n\n- loose three\n\n continued\n\nAfter the list.",
+ "1. first\n\n2. second\n\nText\n\n3) restarted",
+ "```ts\nconst a = 1;\n\n\nconst b = 2;\n```\n\nafter\n\n~~~\nx\n\n~~~~\n\ny\n~~~\n\nend",
+ "> quote\n\n> another quote\n\n> [!NOTE]\n> alert",
+ "| a | b |\n| - | - |\n| 1 | 2 |\n\nAfter the table.",
+ "para\n\n indented code\n\nnext",
+ "Setext\n===\n\nnext\n---\n\n- [ ] task\n- [x] done",
+ ])("renders each block as the whole text renders it, at every streamed prefix: %j", (text) => {
+ for (let end = 0; end <= text.length; end++) {
+ const source = text.slice(0, end);
+ const blocks = splitMarkdownBlocks(source);
+ expect(blocks?.join("")).toBe(source);
+ expect(blocks!.map(html).join("")).toBe(html(source));
+ }
+ });
+
+ it("splits only between closed blocks", () => {
+ expect(splitMarkdownBlocks("a\n\n```\nb\n\nc\n```\n\n- d\n\n- e\n\nf")).toEqual([
+ "a\n\n",
+ "```\nb\n\nc\n```\n\n- d\n\n- e\n\n",
+ "f",
+ ]);
+ });
+
+ it.each([
+ "[ref]\n\n[ref]: /later",
+ "a[^x]\n\n[^x]: note",
+ "\n\nbody\n\n ",
+ ":::note\n\ncontent\n\n:::",
+ "$$\na\n\nb\n$$",
+ "a\r\n\r\nb",
+ ])("keeps text with document-wide syntax whole: %j", (text) => {
+ expect(splitMarkdownBlocks(text)).toBeNull();
+ });
+});
diff --git a/apps/web/src/components/chat/markdownStreamBlocks.ts b/apps/web/src/components/chat/markdownStreamBlocks.ts
new file mode 100644
index 0000000000000..52415ae71977b
--- /dev/null
+++ b/apps/web/src/components/chat/markdownStreamBlocks.ts
@@ -0,0 +1,43 @@
+// Definitions, footnotes, raw HTML, container directives and display math can tie blocks together.
+const DOCUMENT_WIDE_SYNTAX = /^ {0,3}(?:\[[^\]\n]+\]:|<[A-Za-z!?/]|:::|\$\$)|\[\^/m;
+const FENCE_PATTERN = /^ {0,3}(`{3,}|~{3,})/;
+// After a blank line these still continue the previous block: a list item or indented content.
+const CONTINUATION_PATTERN = /^(?:[ \t]|(?:[-*+]|\d{1,9}[.)])(?:[ \t]|$))/;
+
+/**
+ * Cuts Markdown at blank lines that close every open block, so each piece renders exactly as it
+ * would inside the whole text. Returns null when the text uses syntax that spans blocks.
+ */
+export function splitMarkdownBlocks(text: string): string[] | null {
+ if (text.includes("\r") || DOCUMENT_WIDE_SYNTAX.test(text)) return null;
+ const blocks: string[] = [];
+ let blockStart = 0;
+ let lineStart = 0;
+ let fence: string | null = null;
+ let afterBlankLine = false;
+ for (const line of text.split("\n")) {
+ const opener = FENCE_PATTERN.exec(line)?.[1];
+ if (fence !== null) {
+ if (
+ opener &&
+ opener[0] === fence[0] &&
+ opener.length >= fence.length &&
+ line.trim() === opener
+ ) {
+ fence = null;
+ }
+ } else if (line.trim() === "") {
+ afterBlankLine = true;
+ } else {
+ if (afterBlankLine && lineStart > blockStart && !CONTINUATION_PATTERN.test(line)) {
+ blocks.push(text.slice(blockStart, lineStart));
+ blockStart = lineStart;
+ }
+ afterBlankLine = false;
+ fence = opener ?? null;
+ }
+ lineStart += line.length + 1;
+ }
+ blocks.push(text.slice(blockStart));
+ return blocks;
+}
diff --git a/apps/web/src/components/chat/markdownSyntaxGates.ts b/apps/web/src/components/chat/markdownSyntaxGates.ts
new file mode 100644
index 0000000000000..57587a51b9d13
--- /dev/null
+++ b/apps/web/src/components/chat/markdownSyntaxGates.ts
@@ -0,0 +1,204 @@
+import type { Nodes as MdastNodes } from "mdast";
+import {
+ type Extension as MdastExtension,
+ fromMarkdown,
+ type Options as FromMarkdownOptions,
+ type Transform,
+} from "mdast-util-from-markdown";
+import { combineExtensions } from "micromark-util-combine-extensions";
+import type { Construct, Extension, TokenizeContext } from "micromark-util-types";
+import type { Processor } from "unified";
+
+// A table needs a delimiter row: dashes with a `|` or `:`, after any `>` or indent.
+// One character class per pattern: overlapping ones backtrack quadratically on a run of dashes.
+const DELIMITER_LINE = /^[ \t>|:-]+$/gm;
+const isDelimiterRow = (line: string) => line.includes("-") && /[|:]/.test(line);
+const NEXT_LINE = /[^\r\n]*(?:\r\n?|\n)([^\r\n]*)/y;
+
+function hasDelimiterRow(text: string) {
+ for (const [line] of text.matchAll(DELIMITER_LINE)) if (isDelimiterRow(line)) return true;
+ return false;
+}
+const PROTOCOL = /https?:\/\//iy;
+const WWW = /www\./iy;
+const EMAIL_ATEXT = /[\w+.-]*@/y;
+
+const matchesAt = (pattern: RegExp, text: string, offset: number) => {
+ pattern.lastIndex = offset;
+ return pattern.test(text);
+};
+
+interface Gate {
+ readonly names: ReadonlyArray;
+ /** False when the construct cannot match anywhere in the text. */
+ readonly inText: (text: string) => boolean;
+ /** False when it cannot start at this offset, which keeps micromark from trying it there. */
+ readonly at?: (context: TokenizeContext, text: string, offset: number) => boolean;
+}
+
+// micromark tries these at every candidate character: email autolinks at every word, tables
+// at every line. That is most of what GFM adds to a parse, and most texts cannot match them.
+const GATES: ReadonlyArray = [
+ {
+ names: ["emailAutolink"],
+ inText: (text) => text.includes("@"),
+ at: (_, text, offset) => matchesAt(EMAIL_ATEXT, text, offset),
+ },
+ {
+ names: ["protocolAutolink"],
+ inText: (text) => /https?:\/\//i.test(text),
+ at: (_, text, offset) => matchesAt(PROTOCOL, text, offset),
+ },
+ {
+ names: ["wwwAutolink"],
+ inText: (text) => /www\./i.test(text),
+ at: (_, text, offset) => matchesAt(WWW, text, offset),
+ },
+ {
+ names: ["table"],
+ inText: hasDelimiterRow,
+ at: (context, text, offset) => {
+ NEXT_LINE.lastIndex = offset;
+ const nextLine = NEXT_LINE.exec(text)?.[1];
+ return (nextLine !== undefined && hasDelimiterRow(nextLine)) || continuesTable(context);
+ },
+ },
+ { names: ["strikethrough"], inText: (text) => text.includes("~") },
+ {
+ names: ["gfmFootnoteCall", "gfmPotentialFootnoteCall", "gfmFootnoteDefinition"],
+ inText: (text) => text.includes("[^"),
+ },
+ { names: ["tasklistCheck"], inText: (text) => /\[[\sxX]\]/.test(text) },
+];
+
+// A body row follows the head or another row. Mirrors `start` in micromark-extension-gfm-table's
+// lib/syntax.js: recheck it when that package changes.
+function continuesTable({ events }: TokenizeContext) {
+ let index = events.length - 1;
+ while (index > -1 && /^(?:lineEnding|linePrefix)$/.test(events[index]![1].type)) index--;
+ // The table extension's token types are not in micromark's map unless its types are loaded.
+ const tail: string | undefined = events[index]?.[1].type;
+ return tail === "tableHead" || tail === "tableRow";
+}
+
+let parsing = "";
+const gated = new WeakMap();
+
+function gatedConstruct(construct: Construct, gate: Gate): Construct {
+ const at = gate.at;
+ if (!at) return construct;
+ let wrapped = gated.get(construct);
+ if (!wrapped) {
+ const { previous, tokenize } = construct;
+ wrapped = {
+ ...construct,
+ tokenize(effects, ok, nok) {
+ return at(this, parsing, this.now().offset) ? tokenize.call(this, effects, ok, nok) : nok;
+ },
+ ...(previous && {
+ previous(code) {
+ return previous.call(this, code) && at(this, parsing, this.now().offset);
+ },
+ }),
+ };
+ gated.set(construct, wrapped);
+ }
+ return wrapped;
+}
+
+type ConstructMap = Record;
+
+function gateExtension(extension: Extension, absent: ReadonlySet): Extension {
+ const gateOf = (name: string | undefined) =>
+ GATES.find((gate) => name && gate.names.includes(name));
+ const result: Record = {};
+ for (const [field, value] of Object.entries(extension)) {
+ if (field === "disable" || field === "attentionMarkers" || !value) {
+ result[field] = value;
+ continue;
+ }
+ const map: ConstructMap = {};
+ for (const [code, entry] of Object.entries(value as ConstructMap)) {
+ const kept = (Array.isArray(entry) ? entry : [entry]).flatMap((construct) => {
+ const gate = construct && gateOf(construct.name);
+ if (!construct || !gate) return construct ? [construct] : [];
+ return absent.has(gate) ? [] : [gatedConstruct(construct, gate)];
+ });
+ if (kept.length > 0) map[code] = Array.isArray(entry) ? kept : kept[0];
+ }
+ result[field] = map;
+ }
+ return result as Extension;
+}
+
+type MdastExtensions = NonNullable;
+
+// Merged once, as mdast-util-from-markdown merges them on every call: lists in order, handlers by key.
+function mergeMdastExtensions(extensions: MdastExtensions): MdastExtension {
+ const merged = {
+ canContainEols: [] as string[],
+ enter: {},
+ exit: {},
+ transforms: [] as Transform[],
+ };
+ for (const extension of extensions.flat()) {
+ merged.canContainEols.push(...(extension.canContainEols ?? []));
+ Object.assign(merged.enter, extension.enter);
+ Object.assign(merged.exit, extension.exit);
+ // GFM looks for autolink literals again in the decoded text outside links, so `www\.x.io`
+ // links too. Most texts have URLs only in link destinations and code, where it finds nothing.
+ for (const transform of extension.transforms ?? []) {
+ merged.transforms.push(
+ extension.enter?.literalAutolink
+ ? (tree) => (hasAutolinkText(tree) ? transform(tree) : undefined)
+ : transform,
+ );
+ }
+ }
+ return merged;
+}
+
+const AUTOLINK_TEXT = /@|https?:\/\/|www\./i;
+
+function hasAutolinkText(node: MdastNodes): boolean {
+ if (node.type === "text") return AUTOLINK_TEXT.test(node.value);
+ if (node.type === "link" || node.type === "linkReference" || !("children" in node)) return false;
+ return node.children.some(hasAutolinkText);
+}
+
+/**
+ * Parses as remark-parse does, without the syntax extension constructs that cannot match the
+ * text. Same tree, in about half the time.
+ */
+function attachParserWithoutUnusedSyntax(this: Processor) {
+ const data = this.data();
+ const byMask = new Map();
+ let mdastExtensions: MdastExtension[] | undefined;
+ this.parser = (document) => {
+ let mask = 0;
+ GATES.forEach((gate, index) => {
+ if (!gate.inText(document)) mask |= 1 << index;
+ });
+ let extensions = byMask.get(mask);
+ if (!extensions) {
+ const absent = new Set(GATES.filter((_, index) => mask & (1 << index)));
+ extensions = [
+ combineExtensions(
+ (data.micromarkExtensions ?? []).map((extension) => gateExtension(extension, absent)),
+ ),
+ ];
+ byMask.set(mask, extensions);
+ }
+ mdastExtensions ??= [mergeMdastExtensions(data.fromMarkdownExtensions ?? [])];
+ const outer = parsing;
+ // Gates read micromark offsets, which skip a leading byte order mark.
+ parsing = document.charCodeAt(0) === 0xfeff ? document.slice(1) : document;
+ try {
+ return fromMarkdown(document, { ...data.settings, extensions, mdastExtensions });
+ } finally {
+ parsing = outer;
+ }
+ };
+}
+
+export const remarkParseWithoutUnusedSyntax = attachParserWithoutUnusedSyntax;
diff --git a/apps/web/src/components/chat/timelineMinimapItems.test.ts b/apps/web/src/components/chat/timelineMinimapItems.test.ts
index 20d4c75997b1d..776cd39096a8a 100644
--- a/apps/web/src/components/chat/timelineMinimapItems.test.ts
+++ b/apps/web/src/components/chat/timelineMinimapItems.test.ts
@@ -1,6 +1,38 @@
import { describe, expect, it } from "vite-plus/test";
+import { MessageId } from "@t3tools/contracts";
+import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
-import { resolveTimelineMinimapPreview } from "./timelineMinimapItems";
+import { deriveTimelineMinimapItems, resolveTimelineMinimapPreview } from "./timelineMinimapItems";
+
+describe("deriveTimelineMinimapItems", () => {
+ it.each(["", "Ultrathink:\n"])(
+ "omits bootstrap text from the minimap label and tooltip (%j)",
+ (prefix) => {
+ const at = "2026-10-01T00:00:00Z";
+ const items = deriveTimelineMinimapItems([
+ {
+ kind: "message",
+ id: "image-only",
+ createdAt: at,
+ showAssistantMeta: false,
+ showAssistantCopyButton: false,
+ assistantCopyStreaming: false,
+ message: {
+ id: MessageId.make("image-only"),
+ role: "user",
+ text: prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+ runId: null,
+ streaming: false,
+ createdAt: at,
+ updatedAt: at,
+ },
+ },
+ ]);
+ expect(items).toEqual([{ id: "image-only", rowIndex: 0, userText: "", assistantText: null }]);
+ expect(resolveTimelineMinimapPreview(items[0]!)?.userText).toBeNull();
+ },
+ );
+});
describe("resolveTimelineMinimapPreview", () => {
it("previews a thread autolink as prose, not its URL", () => {
diff --git a/apps/web/src/components/chat/timelineMinimapItems.ts b/apps/web/src/components/chat/timelineMinimapItems.ts
index 099c58379ccf6..3c730df680e54 100644
--- a/apps/web/src/components/chat/timelineMinimapItems.ts
+++ b/apps/web/src/components/chat/timelineMinimapItems.ts
@@ -1,4 +1,5 @@
import { parseThreadLinkHref } from "@t3tools/shared/threadLinks";
+import { isAttachmentOnlyBootstrapPrompt } from "@t3tools/shared/composerContextReferences";
import type { Nodes } from "mdast";
import remarkGfm from "remark-gfm";
import remarkParse from "remark-parse";
@@ -26,7 +27,7 @@ export function deriveTimelineMinimapItems(
items.push({
id: row.id,
rowIndex: index,
- userText: row.message.text,
+ userText: isAttachmentOnlyBootstrapPrompt(row.message.text) ? "" : row.message.text,
assistantText: resolveFinalAssistantTextForTurn(rows, index),
});
}
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
index 9c9ac38e1cb1e..cc6e04885c623 100644
--- a/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
+++ b/apps/web/src/components/chat/useQueuedRunEdit.browser.test.tsx
@@ -1,6 +1,7 @@
import type { ThreadStructure } from "@t3tools/client-runtime/state/shell";
import {
EnvironmentId,
+ ChatAttachmentId,
MessageId,
RunId,
ThreadId,
@@ -8,9 +9,13 @@ import {
} from "@t3tools/contracts";
import { useImperativeHandle, type RefObject } from "react";
import { describe, expect, it, vi } from "vite-plus/test";
+import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
+import { toastManager } from "../ui/toast";
import { act, render } from "../../../test/render";
-import { useComposerDraftStore } from "../../composerDraftStore";
+import { useComposerDraftStore, useComposerThreadDraft } from "../../composerDraftStore";
+import { deriveComposerSendState } from "../ChatView.logic";
+import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
import { AppAtomRegistryProvider, appAtomRegistry } from "../../rpc/atomRegistry";
import { useQueuedRunEdit } from "./useQueuedRunEdit";
@@ -34,6 +39,10 @@ vi.mock("../../state/use-atom-command", () => ({
useAtomCommand: () => mocks.editQueuedRun,
}));
+vi.mock("../../hooks/useSettings", () => ({
+ useEnvironmentIdentificationMode: () => "none",
+}));
+
const runsKey = (ref: ScopedThreadRef) => `${ref.environmentId}:${ref.threadId}`;
vi.mock("../../state/threads", async () => {
@@ -88,7 +97,34 @@ function Harness(props: {
composerRef: { current: null },
});
useImperativeHandle(props.hookRef, () => result);
- return null;
+ const draft = useComposerThreadDraft(result.draftTarget);
+ const sendState = deriveComposerSendState({
+ prompt: draft.prompt,
+ imageCount: draft.images.length + draft.files.length,
+ existingAttachmentCount: result.editingAttachments?.length ?? 0,
+ terminalContexts: draft.terminalContexts,
+ });
+ return result.isEditing ? (
+ 0}
+ isSendBusy={result.isSaving}
+ sendDisabledReason={null}
+ isEnvironmentUnavailable={false}
+ isPreparingWorktree={false}
+ hasSendableContent={sendState.hasSendableContent}
+ isEditingQueuedMessage
+ onSubmitMessage={() => void result.saveEdit(savedContent(draft.prompt), () => {})}
+ onPreviousPendingQuestion={() => {}}
+ onInterrupt={() => {}}
+ onImplementPlanInNewThread={() => {}}
+ />
+ ) : null;
}
function view(threadRef: ScopedThreadRef, runStatus: string, hook: { current: HookResult | null }) {
@@ -141,6 +177,94 @@ const promptOf = (ref: ScopedThreadRef) =>
useComposerDraftStore.getState().getComposerDraft(ref)?.prompt ?? "";
describe("useQueuedRunEdit", () => {
+ it.each(["", "Ultrathink:\n"])(
+ "opens attachment-only edits without the placeholder and preserves effort on save (%j)",
+ async (prefix) => {
+ const { hook } = setup();
+ mocks.editQueuedRun.mockResolvedValue({ _tag: "Success" });
+ await using screen = await render(view(THREAD_A, "queued", hook));
+ using toast = vi.spyOn(toastManager, "add");
+ const attachments = [
+ {
+ type: "image" as const,
+ id: ChatAttachmentId.make("kept"),
+ name: "kept.png",
+ mimeType: "image/png",
+ sizeBytes: 10,
+ },
+ ];
+ const request = {
+ runId: RUN,
+ messageId: MessageId.make("message-1"),
+ text: prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+ attachments,
+ };
+ await act(() => requireHook(hook).beginEdit(request));
+ expect(
+ useComposerDraftStore.getState().getComposerDraft(requireHook(hook).draftTarget)?.prompt ??
+ "",
+ ).toBe(prefix.trimEnd());
+ expect(requireHook(hook).editingAttachments?.map(({ attachment }) => attachment)).toEqual(
+ attachments,
+ );
+ await act(() =>
+ useComposerDraftStore
+ .getState()
+ .setRuntimeMode(requireHook(hook).draftTarget, "full-access"),
+ );
+ await act(() => setRuns(THREAD_A, "running"));
+ expect(toast).not.toHaveBeenCalled();
+ expect(requireHook(hook).isEditing).toBe(false);
+ await act(() => setRuns(THREAD_A, "queued"));
+ await act(() => requireHook(hook).beginEdit(request));
+ const update = screen.getByRole("button", { name: "Update queued message" });
+ await expect.element(update).toBeEnabled();
+ await update.click();
+ await vi.waitFor(() => expect(mocks.editQueuedRun).toHaveBeenCalledOnce());
+ expect(mocks.editQueuedRun).toHaveBeenCalledWith(
+ expect.objectContaining({
+ input: expect.objectContaining({
+ text: prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+ edit: expect.objectContaining({ attachments }),
+ }),
+ }),
+ );
+ },
+ );
+
+ it("saves an effort-only prompt without claiming removed attachments remain", async () => {
+ const { hook } = setup();
+ mocks.editQueuedRun.mockResolvedValue({ _tag: "Success" });
+ await using screen = await render(view(THREAD_A, "queued", hook));
+ await act(() =>
+ requireHook(hook).beginEdit({
+ runId: RUN,
+ messageId: MessageId.make("message-1"),
+ text: `Ultrathink:\n${ATTACHMENT_ONLY_BOOTSTRAP_PROMPT}`,
+ attachments: [
+ {
+ type: "image",
+ id: ChatAttachmentId.make("removed"),
+ name: "removed.png",
+ mimeType: "image/png",
+ sizeBytes: 10,
+ },
+ ],
+ }),
+ );
+ await act(() => requireHook(hook).removeEditingAttachment("removed"));
+ await screen.getByRole("button", { name: "Update queued message" }).click();
+ await vi.waitFor(() => expect(mocks.editQueuedRun).toHaveBeenCalledOnce());
+ expect(mocks.editQueuedRun).toHaveBeenCalledWith(
+ expect.objectContaining({
+ input: expect.objectContaining({
+ text: "Ultrathink:",
+ edit: expect.objectContaining({ attachments: [] }),
+ }),
+ }),
+ );
+ });
+
it("keeps an open edit when the user leaves the thread and comes back", async () => {
const { hook } = setup();
await using screen = await render(view(THREAD_A, "queued", hook));
diff --git a/apps/web/src/components/chat/useQueuedRunEdit.ts b/apps/web/src/components/chat/useQueuedRunEdit.ts
index bf317de6898e7..d9185775ea000 100644
--- a/apps/web/src/components/chat/useQueuedRunEdit.ts
+++ b/apps/web/src/components/chat/useQueuedRunEdit.ts
@@ -18,7 +18,10 @@ import {
type ThreadId,
} from "@t3tools/contracts";
import { scopedThreadKey } from "@t3tools/client-runtime/environment";
-import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
+import {
+ restoreAttachmentOnlyBootstrapPrompt,
+ stripAttachmentOnlyBootstrapPrompt,
+} from "@t3tools/shared/composerContextReferences";
import { Atom } from "effect/reactivity";
import type { RefObject } from "react";
import { useAssetUrls } from "../../assets/assetUrls";
@@ -146,7 +149,7 @@ async function submitQueuedRunEdit(input: {
input: {
threadId: editing.threadId,
runId: editing.runId,
- text: editText.length === 0 ? ATTACHMENT_ONLY_BOOTSTRAP_PROMPT : editText,
+ text: restoreAttachmentOnlyBootstrapPrompt(editText, uploads.length > 0),
edit: {
messageId: editing.messageId,
attachments: uploads,
@@ -227,9 +230,10 @@ export function useQueuedRunEdit(input: {
if (activeThreadId === null) return;
if (editing !== null && editing.runId !== request.runId) clearEditDraft(editing.runId);
const target = queuedEditDraftTarget(routeThreadRef, request.runId);
+ const text = stripAttachmentOnlyBootstrapPrompt(request.text);
const store = useComposerDraftStore.getState();
store.clearComposerContent(target);
- store.setPrompt(target, request.text);
+ store.setPrompt(target, text);
const threadRef = { environmentId, threadId: activeThreadId };
queuedRunEdits.begin(
editKey,
@@ -237,7 +241,7 @@ export function useQueuedRunEdit(input: {
threadId: activeThreadId,
runId: request.runId,
messageId: request.messageId,
- originalText: request.text,
+ originalText: text,
existingAttachments: request.attachments,
context: serverProjection?.messages.find((message) => message.id === request.messageId)
?.context,
diff --git a/apps/web/src/components/chat/useThreadLifecycle.tsx b/apps/web/src/components/chat/useThreadLifecycle.tsx
index 0ad8acacf71ce..53c33b5b1ada6 100644
--- a/apps/web/src/components/chat/useThreadLifecycle.tsx
+++ b/apps/web/src/components/chat/useThreadLifecycle.tsx
@@ -87,6 +87,8 @@ interface ThreadLifecycleInput {
readonly activeThread: EnvironmentThreadShell | undefined;
readonly activeThreadId: ThreadId | null;
readonly activeThreadRef: ScopedThreadRef | null;
+ /** Null until the thread's detail may load; see resolveThreadDetailRef. */
+ readonly threadDetailRef: ScopedThreadRef | null;
readonly activeThreadKey: string | null;
readonly activeThreadShell: EnvironmentThreadShell | null;
readonly activeLatestRun: EnvironmentThreadShell["latestRun"];
@@ -138,6 +140,7 @@ export function useThreadLifecycle(input: ThreadLifecycleInput) {
activeThread,
activeThreadId,
activeThreadRef,
+ threadDetailRef,
activeThreadKey,
activeThreadShell,
activeLatestRun,
@@ -524,7 +527,7 @@ export function useThreadLifecycle(input: ThreadLifecycleInput) {
const forceStop = useForceStopThread(environmentId);
const anyRunStop = useAtomValue(
- activeThreadRef ? environmentThreadDetails.runStopAtom(activeThreadRef) : NO_RUN_STOP_ATOM,
+ threadDetailRef ? environmentThreadDetails.runStopAtom(threadDetailRef) : NO_RUN_STOP_ATOM,
);
// A background Stop matters only while that work is still pending.
const runStop = anyRunStop?.background && activeBackgroundTasks.length === 0 ? null : anyRunStop;
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
index a2a0f874d6e90..31ad2028c5f51 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.browser.test.tsx
@@ -1,11 +1,16 @@
-import { EnvironmentId, ProjectId } from "@t3tools/contracts";
-import type { Atom } from "effect/reactivity";
+import { EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";
+import { scopeThreadRef } from "@t3tools/client-runtime/environment";
+import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
+import { AsyncResult, type Atom } from "effect/reactivity";
import { expect, it, vi } from "vite-plus/test";
import { act, render, stubGlobal } from "../../../test/render";
const state = vi.hoisted(() => ({
- projects: [] as never[],
+ projects: [] as EnvironmentProject[],
+ routeParams: {} as Record,
+ preview: vi.fn(),
+ openLink: vi.fn(async () => undefined),
navigate: vi.fn(async (): Promise => undefined),
openScratchProject: vi.fn(async () => null),
confirm: vi.fn(async (_message: string) => true),
@@ -18,7 +23,10 @@ const state = vi.hoisted(() => ({
vi.mock(import("@tanstack/react-router"), async (original) => ({
...(await original()),
useNavigate: (() => state.navigate) as never,
- useRouter: (() => ({ navigate: state.navigate, state: { matches: [] } })) as never,
+ useRouter: (() => ({
+ navigate: state.navigate,
+ state: { matches: [{ params: state.routeParams }] },
+ })) as never,
}));
vi.mock(import("../../state/environments"), async (original) => ({
...(await original()),
@@ -47,11 +55,17 @@ vi.mock(import("../../state/server"), async (original) => {
});
vi.mock(import("../../state/shell"), async (original) => {
const { Atom } = await import("effect/reactivity");
- return { ...(await original()), allReachableShellsLiveAtom: Atom.make(false) };
+ return {
+ ...(await original()),
+ allReachableShellsLiveAtom: Atom.make(false).pipe(Atom.keepAlive),
+ };
});
vi.mock(import("../../state/entities"), async (original) => ({
...(await original()),
readProjects: () => state.projects,
+ readThreadShell: (ref: { threadId: string }) =>
+ ref.threadId === "thread" ? ({ projectId: "effect", worktreePath: null } as never) : null,
+ readProject: () => state.projects[0] ?? null,
}));
vi.mock(import("../../hooks/useScratchProject"), async (original) => ({
...(await original()),
@@ -61,6 +75,10 @@ vi.mock(import("../../hooks/useScratchProject"), async (original) => ({
})) as never,
}));
+vi.mock("../../state/use-atom-query-runner", () => ({
+ useAtomQueryRunner: () => state.preview,
+}));
+vi.mock("../../browser/useOpenLink", () => ({ useOpenLink: () => state.openLink }));
vi.mock(import("../../confirmDialog"), async (original) => ({
...(await original()),
requestConfirmDialog: state.confirm,
@@ -82,6 +100,12 @@ vi.mock(import("../../state/use-atom-command"), async (original) => {
import { AppAtomRegistryProvider, appAtomRegistry } from "../../rpc/atomRegistry";
import { allReachableShellsLiveAtom } from "../../state/shell";
+import { selectThreadDiffPanelSelection, useDiffPanelStore } from "../../diffPanelStore";
+import {
+ selectActiveRightPanel,
+ selectActiveRightPanelSurface,
+ useRightPanelStore,
+} from "../../rightPanelStore";
import { DesktopWebLinkCoordinator } from "./DesktopWebLinkCoordinator";
const discoverySettled = allReachableShellsLiveAtom as Atom.Writable;
@@ -89,6 +113,7 @@ const environmentId = EnvironmentId.make("local");
const projectId = ProjectId.make("effect");
const project = {
id: projectId,
+ workspaceRoot: "/workspace/effect",
environmentId,
repositoryIdentity: {
provider: "github",
@@ -100,7 +125,7 @@ const project = {
remoteUrl: "https://github.com/Effect-TS/effect.git",
},
},
-} as never;
+} as EnvironmentProject;
const pullRequestUrl = "https://github.com/Effect-TS/effect/pull/9339";
const pullRequestView = {
to: "/pull-requests",
@@ -123,6 +148,12 @@ function setup() {
state.confirm.mockResolvedValue(true);
state.localEnvironmentDisabled = false;
state.projects = [];
+ state.routeParams = {};
+ state.preview
+ .mockReset()
+ .mockResolvedValue(AsyncResult.success({ sources: [{ kind: "commit", headRef: sha }] }));
+ useDiffPanelStore.setState({ byThreadKey: {}, branchBaseRefByThreadKey: {} });
+ useRightPanelStore.setState({ byThreadKey: {}, userActionRevisionByThreadKey: {} });
appAtomRegistry.set(discoverySettled, false);
}
@@ -172,6 +203,80 @@ it("holds a launch PR link until project discovery settles, then opens the PR vi
expect(state.openScratchProject).not.toHaveBeenCalled();
});
+const sha = "a".repeat(40);
+const commitUrl = `https://github.com/Effect-TS/effect/pull/9339/commits/${sha}`;
+const threadRef = scopeThreadRef(environmentId, ThreadId.make("thread"));
+
+it.each([
+ ["github.com", "pull/9339/commits"],
+ ["code.example.com:8443", "commit"],
+])("opens a %s/%s commit in the active thread's Diff pane after discovery", async (host, path) => {
+ setup();
+ state.routeParams = { environmentId: "local", threadId: "thread" };
+ await using _coordinator = await mount(`https://${host}/Effect-TS/effect/${path}/${sha}`);
+ expect(state.preview).not.toHaveBeenCalled();
+
+ state.projects = [
+ {
+ ...project,
+ repositoryIdentity: {
+ ...project.repositoryIdentity,
+ canonicalKey: `${host}/effect-ts/effect`,
+ locator: {
+ ...project.repositoryIdentity?.locator,
+ remoteUrl: `https://${host}/Effect-TS/effect.git`,
+ },
+ },
+ } as EnvironmentProject,
+ ];
+ await act(async () => appAtomRegistry.set(discoverySettled, true));
+ await vi.waitFor(() => {
+ expect(selectActiveRightPanel(useRightPanelStore.getState().byThreadKey, threadRef)).toBe(
+ "diff",
+ );
+ });
+ expect(
+ selectThreadDiffPanelSelection(useDiffPanelStore.getState().byThreadKey, threadRef),
+ ).toMatchObject({ kind: "commit", sha });
+ expect(state.preview).toHaveBeenCalledExactlyOnceWith({
+ environmentId,
+ input: expect.objectContaining({ cwd: "/workspace/effect", commitSha: sha }),
+ });
+ expect(state.navigate).not.toHaveBeenCalled();
+ expect(state.openLink).not.toHaveBeenCalled();
+});
+
+it("opens a PR commit the workspace lacks in the thread's PR panel", async () => {
+ setup();
+ state.routeParams = { environmentId: "local", threadId: "thread" };
+ state.projects = [project];
+ state.preview.mockResolvedValueOnce(AsyncResult.success({ sources: [] }));
+ appAtomRegistry.set(discoverySettled, true);
+ await using _coordinator = await mount(commitUrl);
+ await vi.waitFor(() =>
+ expect(
+ selectActiveRightPanelSurface(useRightPanelStore.getState().byThreadKey, threadRef),
+ ).toMatchObject({ kind: "pull-request", repository: "effect-ts/effect", number: 9339 }),
+ );
+ expect(useDiffPanelStore.getState().byThreadKey).toEqual({});
+ expect(state.openLink).not.toHaveBeenCalled();
+});
+
+it("opens a plain commit the workspace lacks like any other delivered link", async () => {
+ setup();
+ state.routeParams = { environmentId: "local", threadId: "thread" };
+ state.projects = [project];
+ state.preview.mockResolvedValueOnce(AsyncResult.success({ sources: [] }));
+ appAtomRegistry.set(discoverySettled, true);
+ const plainCommitUrl = `https://github.com/Effect-TS/effect/commit/${sha}`;
+ await using _coordinator = await mount(plainCommitUrl);
+ await vi.waitFor(() => expect(state.openScratchProject).toHaveBeenCalledOnce());
+ // Handing it to the OS browser would loop when T3 Code is the default browser.
+ expect(state.openLink).not.toHaveBeenCalled();
+ expect(useDiffPanelStore.getState().byThreadKey).toEqual({});
+ expect(useRightPanelStore.getState().byThreadKey).toEqual({});
+});
+
it("adds the backend from a pairing link after the user confirms its host", async () => {
setup();
await using _coordinator = await mount(pairLink);
diff --git a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
index 4ae0b6cdb25b4..ddd892d02bd12 100644
--- a/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
+++ b/apps/web/src/components/desktop/DesktopWebLinkCoordinator.tsx
@@ -27,6 +27,7 @@ import { selectActiveRightPanelSurface, useRightPanelStore } from "../../rightPa
import { appAtomRegistry } from "../../rpc/atomRegistry";
import { resolveThreadRouteTarget } from "../../threadRoutes";
import { assetEnvironment } from "../../state/assets";
+import { readProject, readThreadShell } from "../../state/entities";
import { useEnvironmentHttpBaseUrl, usePrimaryEnvironment } from "../../state/environments";
import { previewEnvironment } from "../../state/preview";
import { allReachableShellsLiveAtom } from "../../state/shell";
@@ -163,25 +164,14 @@ export function DesktopWebLinkCoordinator() {
return threadRef;
};
- const openLink = useEffectEvent(async (url: string) => {
- const pairingUrl = readPairingAppLink(url);
- if (pairingUrl !== null) {
- await pairFromLink(pairingUrl);
- return;
- }
- const appPath = promptLinkAppPath(url);
- if (appPath !== null) {
- await router.navigate({ href: appPath });
- return;
- }
- if (openChangeRequest(externalClick, url)) return;
+ const openInBrowser = useEffectEvent(async (url: string) => {
+ const routeParams = router.state.matches.at(-1)?.params ?? {};
const isFile = url.startsWith("file:");
// Only this machine's environment serves files, so fail before starting a thread.
if (isFile && httpBaseUrl === null) {
reportFailure(url);
return;
}
- const routeParams = router.state.matches.at(-1)?.params ?? {};
const threadRef =
threadShowingBrowser(
routeParams,
@@ -210,15 +200,49 @@ export function DesktopWebLinkCoordinator() {
}
});
+ const openLink = useEffectEvent(async (url: string) => {
+ const pairingUrl = readPairingAppLink(url);
+ if (pairingUrl !== null) {
+ await pairFromLink(pairingUrl);
+ return;
+ }
+ const appPath = promptLinkAppPath(url);
+ if (appPath !== null) {
+ await router.navigate({ href: appPath });
+ return;
+ }
+ const routeParams = router.state.matches.at(-1)?.params ?? {};
+ const routeTarget = resolveThreadRouteTarget(routeParams);
+ const activeThreadRef = routeTarget?.kind === "server" ? routeTarget.threadRef : undefined;
+ const activeThread = activeThreadRef ? readThreadShell(activeThreadRef) : null;
+ const activeProject =
+ activeThread && activeThreadRef
+ ? readProject(scopeProjectRef(activeThreadRef.environmentId, activeThread.projectId))
+ : null;
+ const commitThreadRef =
+ activeThread &&
+ sourceControlClients.parseCommitUrl(url, activeProject?.repositoryIdentity?.provider) !== null
+ ? activeThreadRef
+ : undefined;
+ // A commit the thread's workspace lacks continues here, after its lookup.
+ const openUnavailableCommit = () => {
+ queueRef.current = queueRef.current.then(() => openInBrowser(url)).catch(() => undefined);
+ };
+ if (openChangeRequest(externalClick, url, commitThreadRef, undefined, openUnavailableCommit))
+ return;
+ await openInBrowser(url);
+ });
+
const receiveLink = useEffectEvent((url: string) => {
- // A connected server publishes its config before its project snapshot, so a PR link
- // delivered at launch would miss its project and fall through to the browser. Hold PR
- // links, and only those, until discovery settles; an ordinary link never waits for it.
+ // A connected server publishes its config before its project snapshot, so a source control
+ // link delivered at launch would miss its project and fall through to the browser. Hold
+ // those links until discovery settles; an ordinary link never waits for it.
// Discovery never settles without the local environment, so those links do not wait.
const hold =
openPullRequestsInApp &&
!localEnvironmentDisabled &&
- sourceControlClients.parseChangeRequestUrl(url) !== null
+ (sourceControlClients.parseChangeRequestUrl(url) !== null ||
+ sourceControlClients.parseCommitUrl(url) !== null)
? projectsSettled()
: Promise.resolve();
void hold.then(() => {
diff --git a/apps/web/src/components/diffs/useReviewFilePatches.ts b/apps/web/src/components/diffs/useReviewFilePatches.ts
index b683e13a8f6ee..69dafc2dd7823 100644
--- a/apps/web/src/components/diffs/useReviewFilePatches.ts
+++ b/apps/web/src/components/diffs/useReviewFilePatches.ts
@@ -193,6 +193,7 @@ function reviewFileQueries({
request: {
cwd,
...(baseRef ? { baseRef } : {}),
+ ...(source.kind === "commit" ? { commitSha: source.id } : {}),
ignoreWhitespace,
file: {
path: file.path,
diff --git a/apps/web/src/components/files/AudioPreview.tsx b/apps/web/src/components/files/AudioPreview.tsx
index 0a8f4bcfe16c9..abd05015a9414 100644
--- a/apps/web/src/components/files/AudioPreview.tsx
+++ b/apps/web/src/components/files/AudioPreview.tsx
@@ -15,6 +15,7 @@ type AudioPreviewProps = {
readonly revision?: string | null;
readonly onError?: () => void;
readonly compact?: boolean;
+ readonly variant?: "chip" | "bubble";
readonly failed?: boolean;
readonly onOpen?: (() => void) | undefined;
readonly onRetry?: () => void;
@@ -111,6 +112,7 @@ function AudioChip(props: AudioPreviewProps) {
@@ -140,7 +142,7 @@ function AudioChip(props: AudioPreviewProps) {
>
-
+
{open ? (
-
+
+
+ {isElectron ? (
+
+
+
+
+ ) : null}
+
{pillLabel ? (
@@ -79,8 +96,10 @@ export const SidebarChromeHeader = memo(function SidebarChromeHeader({
});
export function SidebarBrandWidthProbe({
+ isElectron,
onWidthChange,
}: {
+ isElectron: boolean;
onWidthChange: (width: number) => void;
}) {
const observeWidth = (probe: HTMLDivElement) => {
@@ -95,13 +114,56 @@ export function SidebarBrandWidthProbe({
className="pointer-events-none invisible fixed top-0 left-0 flex w-max border-r border-transparent pr-3"
ref={observeWidth}
>
-
);
}
+function HistoryNavigationButton({
+ direction,
+ onBackdrop,
+}: {
+ direction: HistoryDirection;
+ onBackdrop: boolean;
+}) {
+ const keybindings = useAtomValue(primaryServerKeybindingsAtom);
+ const enabled = useCanNavigateHistory(direction);
+ const label = direction === "back" ? "Go back" : "Go forward";
+ const shortcutLabel = shortcutLabelForCommand(
+ keybindings,
+ direction === "back" ? "navigation.back" : "navigation.forward",
+ );
+ const Icon = direction === "back" ? ArrowLeftIcon : ArrowRightIcon;
+ return (
+
+ navigateHistory(direction)}
+ size="icon-sm"
+ variant={onBackdrop ? "media-navigation" : "ghost"}
+ />
+ }
+ >
+
+
+
+ {label}
+ {shortcutLabel ? ` (${shortcutLabel})` : ""}
+
+
+ );
+}
+
function SidebarBrand({ onBackdrop }: { onBackdrop: boolean }) {
return (
;
branchBaseRefByThreadKey: Record;
+ /** A link that selected a commit before opening the closed pane; opening keeps that selection. */
+ keepSelectionOnOpenThreadKey: string | null;
selectGitScope: (ref: ScopedThreadRef, scope: "branch" | "unstaged") => void;
selectBranchBaseRef: (ref: ScopedThreadRef, baseRef: string | null) => void;
selectToolCall: (ref: ScopedThreadRef, target: ToolCallDiffTarget) => void;
selectTurn: (ref: ScopedThreadRef, turnId: RunId, filePath?: string) => void;
+ selectCommit: (ref: ScopedThreadRef, sha: string, keepOnOpen?: boolean) => void;
+ consumeKeepSelectionOnOpen: (ref: ScopedThreadRef) => boolean;
reconcileTurnSelection: (ref: ScopedThreadRef, availableTurnIds: ReadonlyArray) => void;
removeThread: (ref: ScopedThreadRef) => void;
}
@@ -37,19 +42,27 @@ function normalizeBaseRef(baseRef: string | null): string | null {
return normalized ? normalized : null;
}
+function branchBaseRef(
+ state: Pick,
+ threadKey: string,
+): string | null {
+ const previous = state.byThreadKey[threadKey];
+ return previous?.kind === "branch" || previous?.kind === "commit"
+ ? previous.baseRef
+ : (state.branchBaseRefByThreadKey[threadKey] ?? null);
+}
+
export const useDiffPanelStore = create()(
persist(
- (set) => ({
+ (set, get) => ({
byThreadKey: {},
branchBaseRefByThreadKey: {},
+ keepSelectionOnOpenThreadKey: null,
selectGitScope: (ref, scope) =>
set((state) => {
const threadKey = scopedThreadKey(ref);
const previous = state.byThreadKey[threadKey];
- const previousBaseRef =
- previous?.kind === "branch"
- ? previous.baseRef
- : (state.branchBaseRefByThreadKey[threadKey] ?? null);
+ const previousBaseRef = branchBaseRef(state, threadKey);
return {
byThreadKey: {
...state.byThreadKey,
@@ -59,7 +72,7 @@ export const useDiffPanelStore = create()(
: { kind: "unstaged" },
},
branchBaseRefByThreadKey:
- previous?.kind === "branch"
+ previous?.kind === "branch" || previous?.kind === "commit"
? { ...state.branchBaseRefByThreadKey, [threadKey]: previous.baseRef }
: state.branchBaseRefByThreadKey,
};
@@ -102,6 +115,26 @@ export const useDiffPanelStore = create()(
},
};
}),
+ selectCommit: (ref, sha, keepOnOpen = false) =>
+ set((state) => {
+ const threadKey = scopedThreadKey(ref);
+ const baseRef = branchBaseRef(state, threadKey);
+ return {
+ byThreadKey: {
+ ...state.byThreadKey,
+ [threadKey]: { kind: "commit", sha, baseRef },
+ },
+ branchBaseRefByThreadKey: { ...state.branchBaseRefByThreadKey, [threadKey]: baseRef },
+ keepSelectionOnOpenThreadKey: keepOnOpen
+ ? threadKey
+ : state.keepSelectionOnOpenThreadKey,
+ };
+ }),
+ consumeKeepSelectionOnOpen: (ref) => {
+ if (get().keepSelectionOnOpenThreadKey !== scopedThreadKey(ref)) return false;
+ set({ keepSelectionOnOpenThreadKey: null });
+ return true;
+ },
reconcileTurnSelection: (ref, availableTurnIds) =>
set((state) => {
const threadKey = scopedThreadKey(ref);
@@ -178,6 +211,13 @@ export function selectThreadDiffPanelSelection(
return byThreadKey[scopedThreadKey(ref)] ?? DEFAULT_SELECTION;
}
+export function selectThreadBranchBaseRef(
+ state: Pick,
+ ref: ScopedThreadRef | null | undefined,
+): string | null {
+ return ref ? branchBaseRef(state, scopedThreadKey(ref)) : null;
+}
+
export function resolveToolCallDiffTarget(
target: ToolCallDiffTarget,
items: ReadonlyArray,
diff --git a/apps/web/src/keybindings.test.ts b/apps/web/src/keybindings.test.ts
index 78f281ce6f980..c9fe390f5842c 100644
--- a/apps/web/src/keybindings.test.ts
+++ b/apps/web/src/keybindings.test.ts
@@ -21,6 +21,7 @@ import {
resolveShortcutCommand,
shouldShowThreadJumpHintsForModifiers,
shortcutLabelForCommand,
+ terminalNavigationShortcutData,
type ShortcutEventLike,
} from "./keybindings";
@@ -35,6 +36,31 @@ function event(overrides: Partial = {}): ShortcutEventLike {
};
}
+describe("terminal word navigation", () => {
+ it.each(["Win32", "Linux x86_64"])(
+ "leaves Ctrl+Arrow to the terminal encoder on %s",
+ (platform) => {
+ for (const key of ["ArrowLeft", "ArrowRight"]) {
+ assert.equal(terminalNavigationShortcutData(event({ key, ctrlKey: true }), platform), null);
+ }
+ },
+ );
+
+ it.each(["Win32", "Linux x86_64", "MacIntel"])(
+ "preserves Alt+Arrow word navigation on %s",
+ (platform) => {
+ assert.equal(
+ terminalNavigationShortcutData(event({ key: "ArrowLeft", altKey: true }), platform),
+ "\u001bb",
+ );
+ assert.equal(
+ terminalNavigationShortcutData(event({ key: "ArrowRight", altKey: true }), platform),
+ "\u001bf",
+ );
+ },
+ );
+});
+
function modShortcut(
key: string,
overrides: Partial> = {},
diff --git a/apps/web/src/keybindings.ts b/apps/web/src/keybindings.ts
index e9176ddd23c9d..e066f44057187 100644
--- a/apps/web/src/keybindings.ts
+++ b/apps/web/src/keybindings.ts
@@ -469,10 +469,6 @@ export function terminalNavigationShortcutData(
return null;
}
- if (event.ctrlKey && !event.metaKey && !event.altKey) {
- return moveWord;
- }
-
if (event.altKey && !event.metaKey && !event.ctrlKey) {
return moveWord;
}
diff --git a/apps/web/src/lib/openPullRequestLink.browser.test.tsx b/apps/web/src/lib/openPullRequestLink.browser.test.tsx
new file mode 100644
index 0000000000000..a93f32a8902f7
--- /dev/null
+++ b/apps/web/src/lib/openPullRequestLink.browser.test.tsx
@@ -0,0 +1,160 @@
+import { EnvironmentId, ThreadId } from "@t3tools/contracts";
+import { scopeThreadRef, scopedThreadKey } from "@t3tools/client-runtime/environment";
+import { AsyncResult } from "effect/reactivity";
+import { expect, it, vi } from "vite-plus/test";
+import { page } from "vite-plus/test/browser";
+
+import { act, render, stubGlobal } from "../../test/render";
+
+const state = vi.hoisted(() => ({ preview: vi.fn(), openLink: vi.fn() }));
+vi.mock("../state/use-atom-query-runner", () => ({ useAtomQueryRunner: () => state.preview }));
+vi.mock("../browser/useOpenLink", () => ({ useOpenLink: () => state.openLink }));
+vi.mock(import("../state/environments"), async (original) => ({
+ ...(await original()),
+ usePrimaryEnvironmentId: () => EnvironmentId.make("local"),
+}));
+vi.mock("../state/entities", async (original) => ({
+ ...(await original()),
+ readProjects: () => [project],
+ useProjects: () => [project],
+ readProject: () => project,
+ readThreadShell: () => ({ projectId: "project", worktreePath: null }),
+}));
+vi.mock("../state/server", async (original) => {
+ const { Atom } = await import("effect/reactivity");
+ return {
+ ...(await original()),
+ environmentServerConfigsAtom: Atom.make(new Map([["local", {}]])),
+ };
+});
+
+import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts/settings";
+import { __setClientSettingsForTests } from "../hooks/useSettings";
+import { ToastProvider } from "../components/ui/toast";
+import { AppAtomRegistryProvider } from "../rpc/atomRegistry";
+import { useRightPanelStore } from "../rightPanelStore";
+import { useDiffPanelStore } from "../diffPanelStore";
+import { useOpenChangeRequestLink } from "./openPullRequestLink";
+
+const environmentId = EnvironmentId.make("local");
+const threadRef = scopeThreadRef(environmentId, ThreadId.make("thread"));
+const project = {
+ id: "project",
+ environmentId,
+ workspaceRoot: "/repo",
+ repositoryIdentity: {
+ provider: "github",
+ canonicalKey: "github.com/effect-ts/effect",
+ displayName: "Effect-TS/effect",
+ locator: {
+ source: "git-remote",
+ remoteName: "origin",
+ remoteUrl: "https://github.com/Effect-TS/effect.git",
+ },
+ },
+};
+const commitUrl = `https://github.com/Effect-TS/effect/commit/${"a".repeat(40)}?plain=1#diff-original`;
+const pullRequestCommitUrl = `https://github.com/Effect-TS/effect/pull/1/commits/${"a".repeat(40)}`;
+
+function CommitLink({ url = commitUrl }: { url?: string }) {
+ const open = useOpenChangeRequestLink(threadRef);
+ return (
+ open(event, url)}>
+ Commit
+
+ );
+}
+
+function setup() {
+ state.preview.mockReset().mockResolvedValue(AsyncResult.success({ sources: [] }));
+ state.openLink.mockReset().mockResolvedValue(undefined);
+ __setClientSettingsForTests({
+ ...DEFAULT_CLIENT_SETTINGS,
+ pullRequestLinksOpenInApp: true,
+ browserLinkTarget: "system",
+ });
+ useDiffPanelStore.setState({
+ byThreadKey: {},
+ branchBaseRefByThreadKey: {},
+ keepSelectionOnOpenThreadKey: null,
+ });
+ useRightPanelStore.setState({ byThreadKey: {}, userActionRevisionByThreadKey: {} });
+}
+
+it.each([
+ ["shiftKey", commitUrl],
+ ["altKey", commitUrl],
+ ["shiftKey", pullRequestCommitUrl],
+] as const)("keeps %s clicks on %s native", async (modifier, url) => {
+ setup();
+ await using screen = await render(
+
+
+ ,
+ );
+ const event = new MouseEvent("click", { bubbles: true, cancelable: true, [modifier]: true });
+ const defaults: boolean[] = [];
+ screen.container.addEventListener(
+ "click",
+ (nativeEvent) => {
+ defaults.push(nativeEvent.defaultPrevented);
+ nativeEvent.preventDefault();
+ },
+ { once: true },
+ );
+ await act(() => screen.getByRole("link", { name: "Commit" }).element().dispatchEvent(event));
+ expect(defaults).toEqual([false]);
+ expect(state.preview).not.toHaveBeenCalled();
+ expect(useRightPanelStore.getState().byThreadKey).toEqual({});
+});
+
+it.each(["system", "app"] as const)(
+ "offers the original unavailable commit URL when web popups are blocked (%s)",
+ async (browserLinkTarget) => {
+ setup();
+ // Without preview access, the "app" preference opens a popup too.
+ __setClientSettingsForTests({
+ ...DEFAULT_CLIENT_SETTINGS,
+ pullRequestLinksOpenInApp: true,
+ browserLinkTarget,
+ });
+ using _desktop = stubGlobal("desktopBridge", undefined);
+ await using screen = await render(
+
+
+
+
+ ,
+ );
+ using open = vi.spyOn(window, "open").mockReturnValue(null);
+ await screen.getByRole("link", { name: "Commit" }).click();
+ await expect
+ .element(page.getByRole("button", { name: "Open link", exact: true }))
+ .toBeVisible();
+ expect(open).not.toHaveBeenCalled();
+ await page.getByRole("button", { name: "Open link", exact: true }).click();
+ expect(open).toHaveBeenCalledExactlyOnceWith(commitUrl, "_blank", "noopener,noreferrer");
+ expect(state.openLink).not.toHaveBeenCalled();
+ },
+);
+
+it("opens an available commit in the closed Diff pane without the pane resetting it", async () => {
+ setup();
+ const sha = "a".repeat(40);
+ state.preview.mockResolvedValue(
+ AsyncResult.success({ sources: [{ kind: "commit", headRef: sha }] }),
+ );
+ await using screen = await render(
+
+
+ ,
+ );
+ await screen.getByRole("link", { name: "Commit" }).click();
+ await vi.waitFor(() =>
+ expect(useDiffPanelStore.getState().byThreadKey).toEqual({
+ [scopedThreadKey(threadRef)]: { kind: "commit", sha, baseRef: null },
+ }),
+ );
+ // ChatView resets a pane opened without an explicit request to Changes unless this is set.
+ expect(useDiffPanelStore.getState().consumeKeepSelectionOnOpen(threadRef)).toBe(true);
+});
diff --git a/apps/web/src/lib/openPullRequestLink.ts b/apps/web/src/lib/openPullRequestLink.ts
index 014728f058a43..31c04b6263e5f 100644
--- a/apps/web/src/lib/openPullRequestLink.ts
+++ b/apps/web/src/lib/openPullRequestLink.ts
@@ -8,15 +8,25 @@ import {
resolvePullRequestPreviewTarget,
} from "@t3tools/client-runtime/change-request-links";
+import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients";
+
+import { canOpenLinksInApp } from "../browser/browserLinkTarget";
import { useOpenLink } from "../browser/useOpenLink";
import { useClientSettings } from "../hooks/useSettings";
import { stackedThreadToast, toastManager } from "../components/ui/toast";
-import { useRightPanelStore } from "../rightPanelStore";
+import { selectActiveRightPanel, useRightPanelStore } from "../rightPanelStore";
+import {
+ selectThreadBranchBaseRef,
+ selectThreadDiffPanelSelection,
+ useDiffPanelStore,
+} from "../diffPanelStore";
import { appAtomRegistry } from "../rpc/atomRegistry";
-import { readProjects, useProjects } from "../state/entities";
+import { readProject, readProjects, readThreadShell, useProjects } from "../state/entities";
import { environmentServerConfigsAtom, serverEnvironment } from "../state/server";
import { usePrimaryEnvironmentId } from "../state/environments";
+import { reviewEnvironment } from "../state/review";
+import { useAtomQueryRunner } from "../state/use-atom-query-runner";
export function usePullRequestPreviewTarget(environmentId: EnvironmentId | null, url: string) {
const projects = useProjects();
@@ -43,71 +53,178 @@ export function useOpenChangeRequestLink(
event: Pick<
MouseEvent,
"preventDefault" | "stopPropagation" | "metaKey" | "ctrlKey"
- >,
+ > &
+ Partial, "button" | "shiftKey" | "altKey">>,
targetUrl: string,
targetThreadRef?: ScopedThreadRef,
targetEnvironmentId?: EnvironmentId,
+ onCommitUnavailable?: () => void,
) => boolean {
const navigate = useNavigate();
const primaryEnvironmentId = usePrimaryEnvironmentId();
const openInApp = useClientSettings((settings) => settings.pullRequestLinksOpenInApp);
- return (event, targetUrl, targetThreadRef, targetEnvironmentId) => {
+ const ignoreWhitespace = useClientSettings((settings) => settings.diffIgnoreWhitespace);
+ const browserLinkTarget = useClientSettings((settings) => settings.browserLinkTarget);
+ const readDiffPreview = useAtomQueryRunner(reviewEnvironment.diffPreview, {
+ reportFailure: false,
+ refresh: true,
+ });
+ const openLink = useOpenLink(threadRef);
+ return (event, targetUrl, targetThreadRef, targetEnvironmentId, onCommitUnavailable) => {
if (!openInApp || shouldOpenPullRequestExternally(event)) return false;
- // Read at click time: every provider status push replaces the config map, and
- // subscribing would hand every rendered link a new handler. Projects likewise, so a
- // link can resolve against a snapshot that arrived after this handler was built.
- const serverConfigs = appAtomRegistry.get(environmentServerConfigsAtom);
const resolvedThreadRef = targetThreadRef ?? threadRef;
const resolvedPanelRef = panelRef ?? resolvedThreadRef;
- const target = resolveChangeRequestLinkTarget({
- url: targetUrl,
- projects: readProjects(),
- configLoaded: (environmentId) => serverConfigs.has(environmentId),
- environmentId: resolvedThreadRef?.environmentId ?? targetEnvironmentId,
- primaryEnvironmentId,
- lendHostProject: resolvedPanelRef !== undefined,
- });
- if (target === null) return false;
- const { project, repository, number, host } = target;
- event.preventDefault();
- event.stopPropagation();
- const pullRequestsSearch = {
- repository,
- number,
- ...(host === undefined ? {} : { selectedHost: host }),
- selectedProjectId: project.id,
- selectedEnvironmentId: project.environmentId,
- };
- if (resolvedPanelRef) {
- useRightPanelStore.getState().openPullRequest(resolvedPanelRef, {
- // The standalone PR panel has a synthetic ref; each tab keeps its real environment.
- ...(resolvedPanelRef.environmentId === project.environmentId
- ? {}
- : { environmentId: project.environmentId }),
- projectId: project.id,
- ...(host === undefined ? {} : { host }),
- repository,
+ const openPullRequest = () => {
+ // Read at click time: every provider status push replaces the config map, and
+ // subscribing would hand every rendered link a new handler. Projects likewise, so a
+ // link can resolve against a snapshot that arrived after this handler was built.
+ const serverConfigs = appAtomRegistry.get(environmentServerConfigsAtom);
+ const target = resolveChangeRequestLinkTarget({
url: targetUrl,
- number,
+ projects: readProjects(),
+ configLoaded: (environmentId) => serverConfigs.has(environmentId),
+ environmentId: resolvedThreadRef?.environmentId ?? targetEnvironmentId,
+ primaryEnvironmentId,
+ lendHostProject: resolvedPanelRef !== undefined,
});
- if (!resolvedThreadRef) {
- void navigate({
- to: "/pull-requests",
- search: (previous) => ({
- ...previous,
- involvement: previous.involvement ?? "all",
- state: previous.state ?? "all",
- ...pullRequestsSearch,
- }),
- replace: true,
+ if (target === null) return false;
+ const { project, repository, number, host } = target;
+ const pullRequestsSearch = {
+ repository,
+ number,
+ ...(host === undefined ? {} : { selectedHost: host }),
+ selectedProjectId: project.id,
+ selectedEnvironmentId: project.environmentId,
+ };
+ if (resolvedPanelRef) {
+ useRightPanelStore.getState().openPullRequest(resolvedPanelRef, {
+ // The standalone PR panel has a synthetic ref; each tab keeps its real environment.
+ ...(resolvedPanelRef.environmentId === project.environmentId
+ ? {}
+ : { environmentId: project.environmentId }),
+ projectId: project.id,
+ ...(host === undefined ? {} : { host }),
+ repository,
+ url: targetUrl,
+ number,
});
+ if (!resolvedThreadRef) {
+ void navigate({
+ to: "/pull-requests",
+ search: (previous) => ({
+ ...previous,
+ involvement: previous.involvement ?? "all",
+ state: previous.state ?? "all",
+ ...pullRequestsSearch,
+ }),
+ replace: true,
+ });
+ }
+ return true;
}
+ void navigate({
+ to: "/pull-requests",
+ search: { involvement: "all", state: "all", ...pullRequestsSearch },
+ });
+ return true;
+ };
+ const commitThread = resolvedThreadRef ? readThreadShell(resolvedThreadRef) : null;
+ const commitProject =
+ commitThread && resolvedThreadRef
+ ? readProject({
+ environmentId: resolvedThreadRef.environmentId,
+ projectId: commitThread.projectId,
+ })
+ : null;
+ const identity = commitProject?.repositoryIdentity;
+ const parsedCommit = sourceControlClients.parseCommitUrl(targetUrl, identity?.provider);
+ // Shift and Alt keep their browser meaning (new window, download) on commit links.
+ if (parsedCommit !== null && (event.shiftKey || event.altKey)) return false;
+ if (
+ parsedCommit !== null &&
+ commitThread &&
+ resolvedThreadRef &&
+ commitProject?.environmentId === resolvedThreadRef.environmentId &&
+ identity &&
+ identity.provider === parsedCommit.definition.kind &&
+ parsedCommit.definition.isChangeRequestInRepository(identity, parsedCommit.link)
+ ) {
+ const commit = parsedCommit.link;
+ event.preventDefault();
+ event.stopPropagation();
+ const userActionRevision = useRightPanelStore.getState().markUserAction(resolvedThreadRef);
+ const baseRef = selectThreadBranchBaseRef(useDiffPanelStore.getState(), resolvedThreadRef);
+ const selection = selectThreadDiffPanelSelection(
+ useDiffPanelStore.getState().byThreadKey,
+ resolvedThreadRef,
+ );
+ void readDiffPreview({
+ environmentId: resolvedThreadRef.environmentId,
+ input: {
+ cwd: commitThread.worktreePath ?? commitProject.workspaceRoot,
+ ...(baseRef ? { baseRef } : {}),
+ commitSha: commit.sha,
+ ignoreWhitespace,
+ },
+ })
+ .then((result) => {
+ if (
+ useRightPanelStore.getState().getUserActionRevision(resolvedThreadRef) !==
+ userActionRevision ||
+ selectThreadDiffPanelSelection(
+ useDiffPanelStore.getState().byThreadKey,
+ resolvedThreadRef,
+ ) !== selection
+ )
+ return;
+ if (
+ result._tag === "Success" &&
+ result.value.sources.some(
+ (source) => source.kind === "commit" && source.headRef === commit.sha,
+ )
+ ) {
+ const diffOpen =
+ selectActiveRightPanel(
+ useRightPanelStore.getState().byThreadKey,
+ resolvedThreadRef,
+ ) === "diff";
+ useDiffPanelStore.getState().selectCommit(resolvedThreadRef, commit.sha, !diffOpen);
+ useRightPanelStore.getState().open(resolvedThreadRef, "diff");
+ return;
+ }
+ if (openPullRequest()) return;
+ if (onCommitUnavailable) return onCommitUnavailable();
+ // A popup opened after the lookup has lost the click's activation, so browsers block it.
+ if (
+ window.desktopBridge === undefined &&
+ (browserLinkTarget !== "app" || !canOpenLinksInApp(resolvedThreadRef))
+ ) {
+ const toastId = toastManager.add(
+ stackedThreadToast({
+ type: "info",
+ title: "This commit is not in the thread's workspace",
+ actionProps: {
+ children: "Open link",
+ onClick: () => {
+ toastManager.close(toastId);
+ window.open(targetUrl, "_blank", "noopener,noreferrer");
+ },
+ },
+ }),
+ );
+ return;
+ }
+ return openLink(targetUrl, {
+ event: { metaKey: event.metaKey, ctrlKey: event.ctrlKey, button: event.button },
+ threadRef: resolvedThreadRef,
+ });
+ })
+ .catch((error: unknown) => console.error(error));
return true;
}
- void navigate({
- to: "/pull-requests",
- search: { involvement: "all", state: "all", ...pullRequestsSearch },
- });
+ if (!openPullRequest()) return false;
+ event.preventDefault();
+ event.stopPropagation();
return true;
};
}
diff --git a/apps/web/src/navigationHistory.ts b/apps/web/src/navigationHistory.ts
new file mode 100644
index 0000000000000..e062bb8fd7618
--- /dev/null
+++ b/apps/web/src/navigationHistory.ts
@@ -0,0 +1,22 @@
+import { useSyncExternalStore } from "react";
+
+export type HistoryDirection = "back" | "forward";
+
+function subscribeToNavigationHistory(onChange: () => void): () => void {
+ window.navigation.addEventListener("currententrychange", onChange);
+ return () => window.navigation.removeEventListener("currententrychange", onChange);
+}
+
+export function canNavigateHistory(direction: HistoryDirection): boolean {
+ return direction === "back" ? window.navigation.canGoBack : window.navigation.canGoForward;
+}
+
+export function navigateHistory(direction: HistoryDirection) {
+ if (direction === "back") window.history.back();
+ else window.history.forward();
+}
+
+/** Only for Electron: the Navigation API is Chromium-only. */
+export function useCanNavigateHistory(direction: HistoryDirection): boolean {
+ return useSyncExternalStore(subscribeToNavigationHistory, () => canNavigateHistory(direction));
+}
diff --git a/apps/web/src/rightPanelStore.ts b/apps/web/src/rightPanelStore.ts
index 33c537a3cf942..ea043c0298bdb 100644
--- a/apps/web/src/rightPanelStore.ts
+++ b/apps/web/src/rightPanelStore.ts
@@ -109,6 +109,7 @@ interface RightPanelStoreState {
userActionRevisionByThreadKey: Record;
closeRevisionByThreadKey: Record;
getUserActionRevision: (ref: ScopedThreadRef) => number;
+ markUserAction: (ref: ScopedThreadRef) => number;
/** Refused if the user chose a panel after expectedUserActionRevision was read. */
openProactive: (
ref: ScopedThreadRef,
@@ -598,6 +599,16 @@ export const useRightPanelStore = create()(
closeRevisionByThreadKey: {},
getUserActionRevision: (ref) =>
get().userActionRevisionByThreadKey[scopedThreadKey(ref)] ?? 0,
+ markUserAction: (ref) => {
+ const revision = get().getUserActionRevision(ref) + 1;
+ set((state) => ({
+ userActionRevisionByThreadKey: {
+ ...state.userActionRevisionByThreadKey,
+ [scopedThreadKey(ref)]: revision,
+ },
+ }));
+ return revision;
+ },
openProactive: (ref, request, expectedUserActionRevision, activateExisting = false) => {
let opened = false;
set((state) => {
diff --git a/apps/web/src/state/entities.ts b/apps/web/src/state/entities.ts
index 54b367df15b8b..0f94280768d4b 100644
--- a/apps/web/src/state/entities.ts
+++ b/apps/web/src/state/entities.ts
@@ -65,6 +65,9 @@ const EMPTY_VISIBLE_TURN_ITEMS_ATOM = Atom.make(EMPTY_VISIBLE_TURN_ITEMS).pipe(
const EMPTY_CHECKPOINT_SUMMARIES_ATOM = Atom.make>(
Object.freeze([]),
).pipe(Atom.withLabel("web-thread-checkpoint-summaries:empty"));
+const EMPTY_ASSISTANT_MESSAGE_TEXT_ATOM = Atom.make(null).pipe(
+ Atom.withLabel("web-assistant-message-text:empty"),
+);
const EMPTY_LAST_VISITED_AT_ATOM = Atom.make(null).pipe(
Atom.withLabel("web-thread-last-visited:empty"),
);
@@ -212,6 +215,29 @@ export function useThreadVisibleTurnItems(
);
}
+/** Visible turn items held through streamed assistant text; see useAssistantMessageText. */
+export function useTimelineVisibleTurnItems(
+ ref: ScopedThreadRef | null,
+): ReadonlyArray {
+ return useAtomValue(
+ ref === null
+ ? EMPTY_VISIBLE_TURN_ITEMS_ATOM
+ : environmentThreadDetails.timelineVisibleTurnItemsAtom(ref),
+ );
+}
+
+/** One assistant message's live text, or null when the thread does not hold the item. */
+export function useAssistantMessageText(
+ ref: ScopedThreadRef | null,
+ itemId: string | undefined,
+): string | null {
+ return useAtomValue(
+ ref === null || itemId === undefined
+ ? EMPTY_ASSISTANT_MESSAGE_TEXT_ATOM
+ : environmentThreadDetails.assistantMessageTextAtom(ref, itemId),
+ );
+}
+
/** Visible turn items without their streamed text; see ThreadStructure. */
export function useQuietThreadVisibleTurnItems(
ref: ScopedThreadRef | null,
diff --git a/apps/web/src/terminal-links.test.ts b/apps/web/src/terminal-links.test.ts
index 05ed26959bee5..f6df5912ecdd1 100644
--- a/apps/web/src/terminal-links.test.ts
+++ b/apps/web/src/terminal-links.test.ts
@@ -16,6 +16,36 @@ function createBufferLine(text: string, isWrapped = false): TerminalBufferLineLi
}
describe("extractTerminalLinks", () => {
+ it.each([
+ String.raw`C:\dev\ai-test\dir 1`,
+ String.raw`C:\dev\ai-test\dir 1\test`,
+ "C:\\",
+ String.raw`\\server\my share\dir 1`,
+ "/home/Jane Doe/project",
+ String.raw`C:\dev\folder (draft)\name!`,
+ ])("keeps the full PowerShell prompt path %s in one link", (path) => {
+ expect(extractTerminalLinks(`PS ${path}> `)).toEqual([
+ { kind: "path", text: path, start: 3, end: 3 + path.length },
+ ]);
+ });
+
+ it("keeps links in a command separate from the PowerShell prompt path", () => {
+ const path = String.raw`C:\dev\dir 1\test`;
+ const prompt = `PS ${path}> `;
+ const url = "https://example.com";
+ expect(extractTerminalLinks(`${prompt}echo ${url}`)).toEqual([
+ { kind: "path", text: path, start: 3, end: 3 + path.length },
+ { kind: "url", text: url, start: prompt.length + 5, end: prompt.length + 5 + url.length },
+ ]);
+ });
+
+ it("does not extend ordinary output paths through trailing prose", () => {
+ const path = String.raw`C:\dev\project`;
+ expect(extractTerminalLinks(`see ${path} for details`)).toEqual([
+ { kind: "path", text: path, start: 4, end: 4 + path.length },
+ ]);
+ });
+
it.each([
String.raw`src\index.ts:12`,
String.raw`.\src\index.ts:12:7`,
diff --git a/apps/web/src/terminal-links.ts b/apps/web/src/terminal-links.ts
index 48a7c16edbc61..1c078d86cd20f 100644
--- a/apps/web/src/terminal-links.ts
+++ b/apps/web/src/terminal-links.ts
@@ -27,6 +27,8 @@ export interface WrappedTerminalLinkLine {
}
const URL_PATTERN = /https?:\/\/[^\s"'`<>]+/giu;
+// The default PowerShell prompt delimits its unquoted path with `PS ` and `>`.
+const POWERSHELL_PROMPT_PATH_PATTERN = /^PS ((?:[A-Za-z]:[\\/]|\\\\|\/)[^>\r\n]*)>/u;
// Bare paths start only at a segment boundary: hover detection runs this on
// every frame, so separator-free output must not be rescanned at every suffix.
const FILE_PATH_PATTERN =
@@ -104,17 +106,25 @@ function collectMatches(
}
export function extractTerminalLinks(line: string): TerminalLinkMatch[] {
+ const promptPath = POWERSHELL_PROMPT_PATH_PATTERN.exec(line)?.[1];
+ const promptMatches: TerminalLinkMatch[] = promptPath
+ ? [{ kind: "path", text: promptPath, start: 3, end: 3 + promptPath.length }]
+ : [];
const requestRoutes = Array.from(line.matchAll(REQUEST_ROUTE_PATTERN), (match) => ({
start: match.index,
end: match.index + match[0].length,
}));
- const urlMatches = collectMatches(line, "url", URL_PATTERN, []);
- const quotedMatches = collectMatches(line, "path", QUOTED_FILE_PATH_PATTERN, urlMatches);
+ const urlMatches = collectMatches(line, "url", URL_PATTERN, promptMatches);
+ const quotedMatches = collectMatches(line, "path", QUOTED_FILE_PATH_PATTERN, [
+ ...promptMatches,
+ ...urlMatches,
+ ]);
const pathMatches = collectMatches(line, "path", FILE_PATH_PATTERN, [
+ ...promptMatches,
...urlMatches,
...quotedMatches,
]);
- return [...urlMatches, ...quotedMatches, ...pathMatches]
+ return [...promptMatches, ...urlMatches, ...quotedMatches, ...pathMatches]
.filter(
(match) => match.kind === "url" || !requestRoutes.some((route) => overlaps(match, route)),
)
diff --git a/apps/web/src/terminal/ghostty/core.test.ts b/apps/web/src/terminal/ghostty/core.test.ts
index 69bf963ae34c4..7fc9661555e49 100644
--- a/apps/web/src/terminal/ghostty/core.test.ts
+++ b/apps/web/src/terminal/ghostty/core.test.ts
@@ -12,6 +12,7 @@ import {
import { writeTerminalOutputUpdate } from "../../components/ThreadTerminalDrawer";
import { GHOSTTY_CELL_WIDE, GhosttyTerminalCore, ghosttyCellText } from "./core";
import { loadGhosttyRuntime } from "./runtime";
+import { terminalNavigationShortcutData } from "../../keybindings";
vi.mock("./vendor/ghostty-vt.wasm?url", async () => ({
default: (await import("./vendor/ghostty-vt.wasm?inline")).default,
@@ -101,6 +102,26 @@ describe("GhosttyTerminalCore snapshots", () => {
vi.restoreAllMocks();
});
+ it.each([
+ { key: "ArrowLeft", expected: "\x1b[1;5D" },
+ { key: "ArrowRight", expected: "\x1b[1;5C" },
+ ])("sends Ctrl+$key as a modified arrow instead of Alt+B/F", async ({ key, expected }) => {
+ const core = await createCore();
+ const event = {
+ code: key,
+ key,
+ repeat: false,
+ shiftKey: false,
+ ctrlKey: true,
+ altKey: false,
+ metaKey: false,
+ isComposing: false,
+ getModifierState: () => false,
+ } as unknown as KeyboardEvent;
+
+ expect(terminalNavigationShortcutData(event, "Win32") ?? core.encodeKey(event)).toBe(expected);
+ });
+
it.each([
{ code: "", key: "Backspace", expected: "\x7f" },
{ code: "Unidentified", key: "Backspace", expected: "\x7f" },
diff --git a/apps/web/src/terminal/ghostty/surface.test.ts b/apps/web/src/terminal/ghostty/surface.test.ts
index 5473e3c4ffa1c..57018464df49f 100644
--- a/apps/web/src/terminal/ghostty/surface.test.ts
+++ b/apps/web/src/terminal/ghostty/surface.test.ts
@@ -606,12 +606,20 @@ describe("terminalLinkAtPositionWithRange", () => {
row("com/reference", true),
row("~/project/file", false),
row("C:\\repo\\file.ts", false),
+ row("PS C:\\repo\\dir 1", false, true),
+ row("\\test> ", true),
];
expect(terminalLinkAtPositionWithRange(rows, 0, 8)?.text).toBe("https://example.com/reference");
expect(terminalLinkAtPositionWithRange(rows, 1, 4)?.text).toBe("https://example.com/reference");
expect(terminalLinkAtPositionWithRange(rows, 2, 2)?.text).toBe("~/project/file");
expect(terminalLinkAtPositionWithRange(rows, 3, 4)?.text).toBe("C:\\repo\\file.ts");
+ expect(terminalLinkAtPositionWithRange(rows, 4, 13)).toEqual({
+ text: "C:\\repo\\dir 1\\test",
+ range: { start: { x: 3, y: 4 }, end: { x: 4, y: 5 } },
+ });
+ expect(terminalLinkAtPositionWithRange(rows, 5, 2)?.text).toBe("C:\\repo\\dir 1\\test");
+ expect(terminalLinkAtPositionWithRange(rows, 5, 5)).toBeNull();
expect(terminalLinkAtPositionWithRange(rows, 1, 4)).toEqual({
text: "https://example.com/reference",
range: {
diff --git a/apps/web/src/textDirection.ts b/apps/web/src/textDirection.ts
index 58147ea003565..9f0adedd30e3c 100644
--- a/apps/web/src/textDirection.ts
+++ b/apps/web/src/textDirection.ts
@@ -10,6 +10,7 @@ const LETTER = /\p{L}/u;
* Count words so mixed prose follows its main language; break ties with the first word.
*/
export function textDirection(text: string): TextDirection | undefined {
+ if (!RTL_LETTER.test(text)) return LETTER.test(text) ? "ltr" : undefined;
let rtlWords = 0;
let ltrWords = 0;
let first: TextDirection | undefined;
diff --git a/apps/web/test/appScenarios.renders.tsx b/apps/web/test/appScenarios.renders.tsx
index 9c1a7d520eeb1..459f3b9791d7f 100644
--- a/apps/web/test/appScenarios.renders.tsx
+++ b/apps/web/test/appScenarios.renders.tsx
@@ -182,7 +182,7 @@ it("app-stream-assistant-turn", async () => {
const counted = await measure(async () => {
let text = "";
for (let delta = 0; delta < STREAM_DELTAS; delta++) {
- text += `word${delta} `;
+ text += `word${delta}\n\n`;
await act(() =>
emitThreadEvent(LIVE, {
type: "turn-item.updated",
@@ -201,6 +201,13 @@ it("app-stream-assistant-turn", async () => {
.element(page.getByText(`word${STREAM_DELTAS - 1}`, { exact: false }))
.toBeVisible();
});
+ // Only the streaming row changes. The timeline renders for the new item and its layout, not
+ // per delta, and history rows not at all.
+ expect(counted.components.ConversationTimeline).toBeLessThanOrEqual(3);
+ expect(counted.components.UserTimelineRow).toBeUndefined();
+ expect(counted.components.AssistantTimelineRow).toBe(STREAM_DELTAS);
+ // Each delta adds a paragraph; finished blocks keep their render.
+ expect(counted.components.MarkdownParagraph).toBe(STREAM_DELTAS);
await report("app-stream-assistant-turn", [counted], { commits: false });
});
diff --git a/apps/web/test/fakeEnvironment.ts b/apps/web/test/fakeEnvironment.ts
index 26e2ee9fa33a3..c586ad51c2c5f 100644
--- a/apps/web/test/fakeEnvironment.ts
+++ b/apps/web/test/fakeEnvironment.ts
@@ -44,7 +44,7 @@ import * as Stream from "effect/Stream";
import { RpcSchema } from "effect/rpc";
export const ENVIRONMENT_ID = EnvironmentId.make("environment-render");
-const PROJECT_ID = ProjectId.make("project-render");
+export const PROJECT_ID = ProjectId.make("project-render");
const CODEX = ProviderInstanceId.make("codex");
const MODEL = { instanceId: CODEX, model: "gpt-5.4" };
const AT = DateTime.makeUnsafe("2026-03-17T19:12:28.000Z");
diff --git a/docs/user/providers-pi.md b/docs/user/providers-pi.md
index 123258f6ccb43..e106d0afdd387 100644
--- a/docs/user/providers-pi.md
+++ b/docs/user/providers-pi.md
@@ -47,9 +47,10 @@ reporting while a response streams and after it settles.
Pi skills appear in the composer's `$` menu. This includes user skills and project skills that Pi
loads for the current workspace; selecting one uses Pi's native skill expansion.
-Pi loads its normal user and project extensions. Blocking `select`, `confirm`, `input`, and `editor`
-dialogs work in T3 Code. Notifications appear in the work log. Pi terminal decoration such as
-titles, status lines, and widgets does not have a T3 Code equivalent.
+Pi loads its normal user extensions, and project extensions once the folder is trusted in Pi.
+Blocking `select`, `confirm`, `input`, and `editor` dialogs work in T3 Code. Notifications appear in
+the work log. Pi terminal decoration such as titles, status lines, and widgets does not have a T3
+Code equivalent.
## Permission Modes
@@ -79,7 +80,11 @@ threads.
- If no models appear, open Pi directly and confirm its authentication and model configuration.
- If discovery cannot complete, T3 Code keeps Pi available with the `Pi default` model. Start a
thread to let the interactive Pi session handle any startup prompt.
-- If a project extension is missing, approve the project in Pi, then start a fresh provider session.
-- If a project skill is missing from the `$` menu, approve the project in Pi and refresh the provider.
+- If Pi skips project settings, extensions, skills, prompts, MCP servers, or system prompt files
+ because the folder is not trusted, the thread shows a notice on the first turn of the Pi session.
+ Run the configured Pi binary in that folder on the server machine, using the same provider
+ environment, including `PI_CODING_AGENT_DIR` if set. Trust the folder or its parent with `/trust`,
+ then start a new thread using that same worktree. Launch arguments with `--no-approve` keep
+ project files off without the notice.
- The context meter appears once Pi reports usage for the thread. Some model providers only
report usage when a response completes, so the meter can wait for the first reply.
diff --git a/docs/user/source-control.md b/docs/user/source-control.md
index 815e5dd0668fa..9eb2751f9315f 100644
--- a/docs/user/source-control.md
+++ b/docs/user/source-control.md
@@ -10,6 +10,16 @@ rebases, the files Git brought in are left out. A file stays in the list when th
committed it, or fixed a conflict in it. Use the branch comparison to review everything that changed
against your base branch. Restore still returns the complete saved workspace.
+On web and desktop, open the Diff pane source picker and choose **Commits** to review one local
+commit at a time. The list shows the newest 100 commits in the branch comparison. A merge commit
+shows its changes against its first parent.
+
+A commit link from a supported code host opens in the Diff pane when the thread's repository has
+that commit locally, on any branch. Otherwise a pull request commit link opens the pull request. Other
+commit links follow your **Open links in** setting; on web, when that opens a new tab, T3 Code first
+shows an **Open link** button. Command/Ctrl+Click always opens the link in your browser. Commit links follow the **Open pull requests in T3 Code**
+setting in **Settings → Diffs**.
+
## Connect an account
Install Git and configure authentication on the machine running your T3 Code server. For a remote
diff --git a/docs/user/welcome-wizard.md b/docs/user/welcome-wizard.md
index d4604fa7e6668..2d4b589d922fa 100644
--- a/docs/user/welcome-wizard.md
+++ b/docs/user/welcome-wizard.md
@@ -59,7 +59,7 @@ terminal metadata while the terminal process can use them.
## Import your projects
-T3 Code finds directories that Claude Code or Codex has used. Git repositories
+T3 Code finds directories that Claude Code, Codex or Pi has used. Git repositories
are listed first, newest activity on top. When the remote is on GitHub, the
group shows the repository as `owner/name`. Clones with the same remote share
one group. Directories that are not git repositories sit under "Other folders".
@@ -74,8 +74,12 @@ offered.
A large or malformed history can reach the scan limit. T3 Code keeps the
projects it found and warns when projects or conversations may be missing.
-Imported projects include Codex and Claude conversations active within the last
-30 days. You can continue those conversations in T3 Code.
+Imported projects include Claude, Codex and Pi conversations active within the last
+30 days. You can continue those conversations in T3 Code. Pi is off by default:
+enable it in Settings, then open `/welcome` to import its sessions. Pi sessions
+are read from each enabled Pi provider's session directory, which follows
+`PI_CODING_AGENT_SESSION_DIR` and `PI_CODING_AGENT_DIR` in its environment. A
+Pi conversation imports its active branch, the one Pi reopens.
Conversation import is best effort. T3 Code keeps the first user prompt and the
newest remaining visible user and assistant messages, with 200 messages total.
diff --git a/infra/relay/src/environments/ManagedEndpointProvider.test.ts b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
index 01230171be9ba..96661fad42a61 100644
--- a/infra/relay/src/environments/ManagedEndpointProvider.test.ts
+++ b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
@@ -343,6 +343,7 @@ function makeTunnelLimits(
}
return yield* reserve;
}),
+ getOverride: () => Effect.die("unused"),
});
}
diff --git a/infra/relay/src/environments/ManagedTunnelLimits.test.ts b/infra/relay/src/environments/ManagedTunnelLimits.test.ts
index 6aca885b85b87..6b8dd817ee01c 100644
--- a/infra/relay/src/environments/ManagedTunnelLimits.test.ts
+++ b/infra/relay/src/environments/ManagedTunnelLimits.test.ts
@@ -121,6 +121,27 @@ const reserve = (
),
);
+const getOverride = (override?: number) =>
+ Effect.gen(function* () {
+ const limits = yield* ManagedTunnelLimits.ManagedTunnelLimits;
+ return yield* limits.getOverride({ userId: "user-1" });
+ }).pipe(
+ Effect.provide(
+ ManagedTunnelLimits.layer.pipe(
+ Layer.provide(
+ Layer.succeed(
+ RelayDb.RelayDb,
+ makeFakeDb({
+ otherSlots: () => 0,
+ ...(override === undefined ? {} : { override }),
+ }),
+ ),
+ ),
+ Layer.provide(t3ChatLayer("free")),
+ ),
+ ),
+ );
+
describe("ManagedTunnelLimits", () => {
it.effect("rejects concurrent reservations past the limit", () => {
const reserved: Array = [];
@@ -383,7 +404,9 @@ describe("ManagedTunnelLimits", () => {
reserve({ override, activeTunnels: override, plan: "premier", lookups }),
);
expect(error).toMatchObject({ _tag: "ManagedTunnelLimitExceeded", maxTunnels: override });
+ expect(yield* getOverride(override)).toBe(override);
}
+ expect(yield* getOverride()).toBeNull();
expect(lookups).toEqual([]);
}),
);
diff --git a/infra/relay/src/environments/ManagedTunnelLimits.ts b/infra/relay/src/environments/ManagedTunnelLimits.ts
index aa373ad27ffb2..3af90f86c4163 100644
--- a/infra/relay/src/environments/ManagedTunnelLimits.ts
+++ b/infra/relay/src/environments/ManagedTunnelLimits.ts
@@ -106,6 +106,10 @@ export class ManagedTunnelLimits extends Context.Service<
input: { readonly userId: string; readonly environmentId: string },
reserve: Effect.Effect,
) => Effect.Effect;
+ /** The user's manual cap, which replaces the default and any T3 Chat plan cap. */
+ readonly getOverride: (input: {
+ readonly userId: string;
+ }) => Effect.Effect;
}
>()("t3code-relay/environments/ManagedTunnelLimits") {}
@@ -126,7 +130,24 @@ const make = Effect.gen(function* () {
),
);
+ const loadOverride = (userId: string) =>
+ db
+ .select({ maxTunnels: relayManagedTunnelLimits.maxTunnels })
+ .from(relayManagedTunnelLimits)
+ .where(eq(relayManagedTunnelLimits.userId, userId))
+ .limit(1)
+ .pipe(
+ Effect.map((rows) => rows[0]?.maxTunnels ?? null),
+ Effect.mapError(
+ (cause) =>
+ new ManagedTunnelLimitPersistenceError({ operation: "load-limit", userId, cause }),
+ ),
+ );
+
return ManagedTunnelLimits.of({
+ getOverride: Effect.fn("relay.managed_tunnel_limits.get_override")(function* (input) {
+ return yield* loadOverride(input.userId);
+ }),
withCapacity: Effect.fn("relay.managed_tunnel_limits.with_capacity")(function* (
input: { readonly userId: string; readonly environmentId: string },
reserve: Effect.Effect,
@@ -148,22 +169,8 @@ const make = Effect.gen(function* () {
),
);
- const overrides = yield* db
- .select({ maxTunnels: relayManagedTunnelLimits.maxTunnels })
- .from(relayManagedTunnelLimits)
- .where(eq(relayManagedTunnelLimits.userId, input.userId))
- .limit(1)
- .pipe(
- Effect.mapError(
- (cause) =>
- new ManagedTunnelLimitPersistenceError({
- operation: "load-limit",
- userId: input.userId,
- cause,
- }),
- ),
- );
- const baseMaxTunnels = overrides[0]?.maxTunnels ?? DEFAULT_MANAGED_TUNNEL_LIMIT;
+ const override = yield* loadOverride(input.userId);
+ const baseMaxTunnels = override ?? DEFAULT_MANAGED_TUNNEL_LIMIT;
const pendingCutoff = DateTime.formatIso(
DateTime.subtract(yield* DateTime.now, {
@@ -196,7 +203,7 @@ const make = Effect.gen(function* () {
// A manual override is the exact cap; a T3 Chat plan raises only the default.
// Runs under the user lock, bounded by the T3 Chat request timeout.
const maxTunnels =
- t3Chat.available && overrides.length === 0
+ t3Chat.available && override === null
? Math.max(baseMaxTunnels, yield* t3ChatTunnelLimit(input.userId))
: baseMaxTunnels;
if (activeTunnels >= maxTunnels) {
diff --git a/infra/relay/src/http/Api.test.ts b/infra/relay/src/http/Api.test.ts
index a20989cd3c025..e6db7fc8b7aa0 100644
--- a/infra/relay/src/http/Api.test.ts
+++ b/infra/relay/src/http/Api.test.ts
@@ -64,6 +64,7 @@ import * as HookInbox from "../hooks/HookInbox.ts";
import * as EnvironmentLinks from "../environments/EnvironmentLinks.ts";
import * as ManagedEndpointAllocations from "../environments/ManagedEndpointAllocations.ts";
import * as ManagedEndpointProvider from "../environments/ManagedEndpointProvider.ts";
+import * as ManagedTunnelLimits from "../environments/ManagedTunnelLimits.ts";
import * as AgentActivityPublisher from "../agentActivity/AgentActivityPublisher.ts";
import * as EnvironmentPublishSignatures from "../environments/EnvironmentPublishSignatures.ts";
import * as T3ChatAccounts from "../t3chat/T3ChatAccounts.ts";
@@ -130,6 +131,7 @@ describe("managed endpoint provisioning errors", () => {
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(Devices.Devices, {}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
+ Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
@@ -241,6 +243,7 @@ describe("device listing compatibility", () => {
},
}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
+ Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
@@ -322,6 +325,7 @@ describe("Cloudflare rate-limit retry hint", () => {
Layer.mock(ManagedEndpointProvider.ManagedEndpointProvider, {}),
Layer.mock(Devices.Devices, {}),
Layer.mock(T3ChatAccounts.T3ChatAccounts, { available: false }),
+ Layer.mock(ManagedTunnelLimits.ManagedTunnelLimits, {}),
),
),
Layer.provideMerge(
diff --git a/infra/relay/src/http/Api.ts b/infra/relay/src/http/Api.ts
index 5a4d77c28d3c2..390f3c18f785f 100644
--- a/infra/relay/src/http/Api.ts
+++ b/infra/relay/src/http/Api.ts
@@ -74,6 +74,7 @@ import * as AgentActivityPublisher from "../agentActivity/AgentActivityPublisher
import * as EnvironmentConnector from "../environments/EnvironmentConnector.ts";
import * as EnvironmentLinker from "../environments/EnvironmentLinker.ts";
import * as ManagedEndpointProvider from "../environments/ManagedEndpointProvider.ts";
+import * as ManagedTunnelLimits from "../environments/ManagedTunnelLimits.ts";
import * as ManagedEndpointAllocations from "../environments/ManagedEndpointAllocations.ts";
import * as EnvironmentPublishSignatures from "../environments/EnvironmentPublishSignatures.ts";
import * as MobileRegistrations from "../agentActivity/MobileRegistrations.ts";
@@ -825,6 +826,7 @@ export const layerClientApi = HttpApiBuilder.group(
const managedEndpointProvider = yield* ManagedEndpointProvider.ManagedEndpointProvider;
const devices = yield* Devices.Devices;
const t3Chat = yield* T3ChatAccounts.T3ChatAccounts;
+ const tunnelLimits = yield* ManagedTunnelLimits.ManagedTunnelLimits;
return handlers
.handle(
"listEnvironments",
@@ -996,12 +998,20 @@ export const layerClientApi = HttpApiBuilder.group(
"getT3ChatLink",
Effect.fn("relay.api.client.getT3ChatLink")(function* () {
yield* appendRelayCredentialResponseHeaders;
- if (!t3Chat.available) return { available: false, link: null };
const { userId } = yield* RelayClientPrincipal;
- const link = yield* t3Chat
- .getLink({ userId })
- .pipe(Effect.catch(() => relayInternalErrorResponse("upstream_unavailable")));
- return { available: true, link };
+ const link = t3Chat.available
+ ? yield* t3Chat
+ .getLink({ userId })
+ .pipe(Effect.catch(() => relayInternalErrorResponse("upstream_unavailable")))
+ : null;
+ const maxTunnelsOverride = yield* tunnelLimits
+ .getOverride({ userId })
+ .pipe(Effect.catch(() => relayInternalErrorResponse("internal_error")));
+ return {
+ available: t3Chat.available,
+ link,
+ ...(maxTunnelsOverride === null ? {} : { maxTunnelsOverride }),
+ };
}, mapRelayCommonApiErrors("not_authorized")),
)
.handle(
diff --git a/packages/client-runtime/src/changeRequestLinks.ts b/packages/client-runtime/src/changeRequestLinks.ts
index 2983647f3e26f..76f60a5953f2b 100644
--- a/packages/client-runtime/src/changeRequestLinks.ts
+++ b/packages/client-runtime/src/changeRequestLinks.ts
@@ -150,3 +150,21 @@ export function projectChangeRequestUrl(
...(ownRepository && identity.webUrl !== undefined ? { webUrl: identity.webUrl } : {}),
});
}
+
+export function projectCommitUrl(
+ identity: RepositoryIdentity | null | undefined,
+ sha: string,
+): string | null {
+ if (identity?.provider === undefined) return null;
+ const [host, ...path] = identity.canonicalKey.split("/");
+ if (!host) return null;
+ return (
+ sourceControlClients.get(identity.provider).commitUrl?.({
+ host,
+ repository: path.join("/"),
+ sha,
+ remoteUrl: identity.locator.remoteUrl.trim(),
+ ...(identity.webUrl !== undefined ? { webUrl: identity.webUrl } : {}),
+ }) ?? null
+ );
+}
diff --git a/packages/client-runtime/src/state/review.ts b/packages/client-runtime/src/state/review.ts
index 691212aedd501..6700be9af657a 100644
--- a/packages/client-runtime/src/state/review.ts
+++ b/packages/client-runtime/src/state/review.ts
@@ -51,6 +51,11 @@ export function createReviewEnvironmentAtoms(
});
});
return {
+ branchCommits: createEnvironmentRpcQueryAtomFamily(runtime, {
+ label: "environment-data:review:branch-commits",
+ tag: WS_METHODS.reviewGetBranchCommits,
+ staleTimeMs: 5_000,
+ }),
diffPreview,
diffFilePatch: createEnvironmentQueryAtomFamily(runtime, {
label: "environment-data:review:diff-file-patch",
diff --git a/packages/client-runtime/src/state/terminalOutput.ts b/packages/client-runtime/src/state/terminalOutput.ts
index 5c4f8422c1f7d..df4d2ee03955c 100644
--- a/packages/client-runtime/src/state/terminalOutput.ts
+++ b/packages/client-runtime/src/state/terminalOutput.ts
@@ -286,9 +286,14 @@ export function readTerminalOutputUpdate(
return { type: "reset", data: terminalOutputText(output), cursor: nextCursor };
}
- const appended = output.chunks.filter(
- (chunk) => chunk.startOffset + chunk.data.length > cursor.offset,
- );
+ // Appends and compaction preserve offset order, so unread chunks form a suffix.
+ let firstUnread = output.chunks.length;
+ while (firstUnread > 0) {
+ const chunk = output.chunks[firstUnread - 1]!;
+ if (!(chunk.startOffset + chunk.data.length > cursor.offset)) break;
+ firstUnread -= 1;
+ }
+ const appended = output.chunks.slice(firstUnread);
if (appended.length === 0) {
return { type: "none", cursor: nextCursor };
}
diff --git a/packages/client-runtime/src/state/terminalSession.test.ts b/packages/client-runtime/src/state/terminalSession.test.ts
index a04504e00ee3b..7cbcd14f819fb 100644
--- a/packages/client-runtime/src/state/terminalSession.test.ts
+++ b/packages/client-runtime/src/state/terminalSession.test.ts
@@ -166,6 +166,46 @@ describe("terminal session reducers", () => {
expect(readTerminalOutputUpdate(state.output, update.cursor).type).toBe("none");
});
+ it("bounds historical chunk inspection when reading new tail output", () => {
+ let state = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
+ type: "snapshot",
+ snapshot: { ...BASE_SNAPSHOT, history: "" },
+ });
+ for (let index = 0; index < 512; index += 1) {
+ state = applyTerminalAttachStreamEvent(state, {
+ type: "output",
+ threadId: TARGET.threadId,
+ terminalId: TARGET.terminalId,
+ data: "history\r\n",
+ });
+ }
+ const cursor = readTerminalOutputUpdate(state.output, INITIAL_TERMINAL_OUTPUT_CURSOR).cursor;
+ const next = applyTerminalAttachStreamEvent(state, {
+ type: "output",
+ threadId: TARGET.threadId,
+ terminalId: TARGET.terminalId,
+ data: "latest\r\n",
+ });
+ let historicalChunkReads = 0;
+ const chunks = next.output.chunks.map((chunk, index) =>
+ index < state.output.chunks.length
+ ? {
+ ...chunk,
+ get startOffset() {
+ historicalChunkReads += 1;
+ return chunk.startOffset;
+ },
+ }
+ : chunk,
+ );
+
+ expect(readTerminalOutputUpdate({ ...next.output, chunks }, cursor)).toMatchObject({
+ type: "append",
+ data: "latest\r\n",
+ });
+ expect(historicalChunkReads).toBeLessThanOrEqual(2);
+ });
+
it("preserves the byte-limited tail and resets a cursor before a partially trimmed chunk", () => {
const initial = applyTerminalAttachStreamEvent(EMPTY_TERMINAL_BUFFER_STATE, {
type: "snapshot",
diff --git a/packages/client-runtime/src/state/threadDetail.test.ts b/packages/client-runtime/src/state/threadDetail.test.ts
index 8fc01839183fe..3e66202d0bb4b 100644
--- a/packages/client-runtime/src/state/threadDetail.test.ts
+++ b/packages/client-runtime/src/state/threadDetail.test.ts
@@ -197,6 +197,42 @@ describe("quietThreadAtom", () => {
});
});
+describe("timelineVisibleTurnItemsAtom", () => {
+ const ref = { environmentId: EnvironmentId.make("environment-1"), threadId: v2ThreadId };
+
+ it("holds through streamed assistant text while the message reads its own text", () => {
+ const stateAtom = Atom.make(
+ AsyncResult.success({
+ ...EMPTY_ENVIRONMENT_THREAD_STATE,
+ data: Option.some(withItem(assistant)),
+ }),
+ );
+ const details = createEnvironmentThreadDetailAtoms(() => stateAtom);
+ const timelineAtom = details.timelineVisibleTurnItemsAtom(ref);
+ const textAtom = details.assistantMessageTextAtom(ref, assistant.id);
+ const registry = AtomRegistry.make();
+ registry.mount(timelineAtom);
+ registry.mount(textAtom);
+ const push = (item: OrchestrationV2TurnItem) =>
+ registry.set(
+ stateAtom,
+ AsyncResult.success({
+ ...EMPTY_ENVIRONMENT_THREAD_STATE,
+ data: Option.some(withItem(item, later)),
+ }),
+ );
+ const first = registry.get(timelineAtom);
+
+ push({ ...assistant, text: "Hello", updatedAt: later });
+ expect(registry.get(timelineAtom)).toBe(first);
+ expect(registry.get(textAtom)).toBe("Hello");
+
+ push({ ...assistant, text: "Hello", streaming: false, status: "completed" });
+ expect(registry.get(timelineAtom)[0]?.item).toMatchObject({ text: "Hello", streaming: false });
+ registry.dispose();
+ });
+});
+
it("only compares replaced entries in a streamed reducer delta", () => {
const size = 100;
let slotReads = 0;
diff --git a/packages/client-runtime/src/state/threadDetail.ts b/packages/client-runtime/src/state/threadDetail.ts
index 3819c5d92ba5e..eeeda6a2f348f 100644
--- a/packages/client-runtime/src/state/threadDetail.ts
+++ b/packages/client-runtime/src/state/threadDetail.ts
@@ -148,6 +148,26 @@ function sameVisibleTurnItemStructure(before: VisibleTurnItem, after: VisibleTur
);
}
+function isStreamingAssistantMessage(visibleItem: VisibleTurnItem): boolean {
+ return visibleItem.item.type === "assistant_message" && visibleItem.item.streaming;
+}
+
+/** Whether `next` only streams more text into assistant messages that were already streaming. */
+function sameApartFromStreamedAssistantText(
+ previous: OrchestrationV2ThreadProjection["visibleTurnItems"],
+ next: OrchestrationV2ThreadProjection["visibleTurnItems"],
+): boolean {
+ return sameProjectionArray(
+ previous,
+ next,
+ (before, after) =>
+ before === after ||
+ (isStreamingAssistantMessage(before) &&
+ isStreamingAssistantMessage(after) &&
+ sameVisibleTurnItemStructure(before, after)),
+ );
+}
+
/**
* Whether `previous` and `next` have the same ThreadStructure: they differ
* only by text streamed into existing assistant and reasoning items or by a
@@ -267,6 +287,32 @@ export function createEnvironmentThreadDetailAtoms(
);
});
+ // Holds while only streamed assistant text moves, so the timeline re-renders on structure;
+ // each streaming message reads its text through assistantMessageTextAtom.
+ const timelineVisibleTurnItemsAtomFamily = Atom.family((key: string) => {
+ let previous = EMPTY_VISIBLE_TURN_ITEMS;
+ return Atom.make((get) => {
+ const next = get(visibleTurnItemsAtomFamily(key));
+ if (!sameApartFromStreamedAssistantText(previous, next)) previous = next;
+ return previous;
+ }).pipe(
+ Atom.setIdleTTL(0),
+ Atom.withLabel(`environment-thread-timeline-visible-turn-items:${key}`),
+ );
+ });
+
+ const assistantMessageTextAtomFamily = Atom.family((key: string) => {
+ const separator = key.lastIndexOf("\u0000");
+ const thread = key.slice(0, separator);
+ const itemId = key.slice(separator + 1);
+ return Atom.make((get) => {
+ const item = get(visibleTurnItemsAtomFamily(thread)).find(
+ (visibleItem) => visibleItem.item.id === itemId,
+ )?.item;
+ return item?.type === "assistant_message" ? item.text : null;
+ }).pipe(Atom.setIdleTTL(0), Atom.withLabel(`environment-thread-assistant-message-text:${key}`));
+ });
+
const queueWorkflowAtomFamily = Atom.family((key: string) => {
let previous: Pick<
OrchestrationV2ThreadProjection,
@@ -472,6 +518,10 @@ export function createEnvironmentThreadDetailAtoms(
visibleTurnItemsAtom: (ref: ScopedThreadRef) => visibleTurnItemsAtomFamily(threadKey(ref)),
quietVisibleTurnItemsAtom: (ref: ScopedThreadRef) =>
quietVisibleTurnItemsAtomFamily(threadKey(ref)),
+ timelineVisibleTurnItemsAtom: (ref: ScopedThreadRef) =>
+ timelineVisibleTurnItemsAtomFamily(threadKey(ref)),
+ assistantMessageTextAtom: (ref: ScopedThreadRef, itemId: string) =>
+ assistantMessageTextAtomFamily(`${threadKey(ref)}\u0000${itemId}`),
statusAtom: (ref: ScopedThreadRef) => statusAtomFamily(threadKey(ref)),
sequenceAtom: (ref: ScopedThreadRef) => sequenceAtomFamily(threadKey(ref)),
errorAtom: (ref: ScopedThreadRef) => errorAtomFamily(threadKey(ref)),
diff --git a/packages/client-runtime/src/userMessage.test.ts b/packages/client-runtime/src/userMessage.test.ts
index 207939cf2f39d..44529f6c14557 100644
--- a/packages/client-runtime/src/userMessage.test.ts
+++ b/packages/client-runtime/src/userMessage.test.ts
@@ -1,9 +1,157 @@
import { describe, expect, it } from "vite-plus/test";
-import { GuestMessageId } from "@t3tools/contracts";
+import { ComposerContextId, GuestMessageId, ScheduledTaskId } from "@t3tools/contracts";
import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
-import { resolveUserMessagePresentation } from "./userMessage.ts";
+import {
+ resolveUserMessageFileCards,
+ resolveUserMessageGrouping,
+ resolveUserMessagePresentation,
+} from "./userMessage.ts";
+
+describe("resolveUserMessageGrouping", () => {
+ const own = { role: "user", text: "hello" };
+
+ it("groups only adjacent own messages", () => {
+ expect(resolveUserMessageGrouping(own, own, own)).toEqual({
+ groupedWithPrevious: true,
+ groupedWithNext: true,
+ continuesSteer: false,
+ });
+ expect(resolveUserMessageGrouping(own, undefined, own)).toMatchObject({
+ groupedWithPrevious: false,
+ groupedWithNext: true,
+ });
+ for (const boundary of [
+ undefined,
+ { ...own, role: "assistant" },
+ { ...own, createdBy: "agent" as const },
+ { ...own, createdBy: "agent" as const, creationSource: "server" as const },
+ { ...own, scheduledTaskId: ScheduledTaskId.make("task") },
+ {
+ ...own,
+ context: {
+ guest: { guestMessageId: GuestMessageId.make("guest"), name: "Sam", text: "hi" },
+ },
+ },
+ ]) {
+ expect(resolveUserMessageGrouping(own, boundary, boundary)).toEqual({
+ groupedWithPrevious: false,
+ groupedWithNext: false,
+ continuesSteer: false,
+ });
+ expect(resolveUserMessageGrouping(boundary, own, own)).toEqual({
+ groupedWithPrevious: false,
+ groupedWithNext: false,
+ continuesSteer: false,
+ });
+ }
+ });
+
+ it("shows one label for consecutive steers, including promoted queued messages", () => {
+ for (const inputIntent of ["steer", "promoted_queued_to_steer"] as const) {
+ const steer = { ...own, inputIntent };
+ expect(
+ resolveUserMessageGrouping(steer, { ...own, inputIntent: "steer" }, undefined)
+ .continuesSteer,
+ ).toBe(true);
+ expect(
+ resolveUserMessageGrouping(
+ steer,
+ { ...own, inputIntent: "promoted_queued_to_steer" },
+ undefined,
+ ).continuesSteer,
+ ).toBe(true);
+ expect(resolveUserMessageGrouping(steer, own, undefined).continuesSteer).toBe(false);
+ expect(resolveUserMessageGrouping(own, steer, undefined).continuesSteer).toBe(false);
+ }
+ });
+});
+
+describe("resolveUserMessageFileCards", () => {
+ const file = {
+ type: "file" as const,
+ id: "report",
+ name: "report.pdf",
+ mimeType: "application/pdf",
+ sizeBytes: 1024,
+ };
+ const record = {
+ ...file,
+ version: 1 as const,
+ kind: "file" as const,
+ contextId: ComposerContextId.make("report"),
+ label: file.name,
+ attachmentId: file.id,
+ };
+ const context = { version: 1 as const, records: [record] };
+ const reference = "[report.pdf](t3-context://v1/file/report)";
+
+ it("shows file cards for bare attachments and bound file references", () => {
+ for (const text of ["", " \n", reference]) {
+ expect(resolveUserMessageFileCards({ text, attachments: [file], context })).toEqual([file]);
+ }
+ expect(
+ resolveUserMessageFileCards({
+ text: `${reference}\n${reference}`,
+ attachments: [file],
+ context,
+ }),
+ ).toEqual([file]);
+ });
+
+ it("keeps words and unavailable or non-file references in the bubble", () => {
+ for (const text of [
+ `read ${reference}`,
+ "[missing.pdf](t3-context://v1/file/missing)",
+ "[report.pdf](t3-context://v1/mention/report)",
+ ]) {
+ expect(resolveUserMessageFileCards({ text, attachments: [file], context })).toBeNull();
+ }
+ expect(resolveUserMessageFileCards({ text: reference, attachments: [file] })).toBeNull();
+ expect(
+ resolveUserMessageFileCards({
+ text: reference,
+ attachments: [file],
+ context: {
+ version: 1,
+ records: [
+ {
+ version: 1,
+ kind: "file",
+ contextId: record.contextId,
+ label: file.name,
+ payload: {},
+ },
+ ],
+ },
+ }),
+ ).toBeNull();
+ expect(
+ resolveUserMessageFileCards({
+ text: reference,
+ attachments: [{ ...file, id: "other" }],
+ context,
+ }),
+ ).toBeNull();
+ });
+
+ it("keeps media, unknown attachments, and empty messages out of the file cards", () => {
+ const media = [
+ { ...file, type: "image" as const, name: "photo.png", mimeType: "image/png" },
+ { ...file, name: "photo.png", mimeType: "application/octet-stream" },
+ { ...file, name: "clip.mp4", mimeType: "video/mp4" },
+ { ...file, name: "clip.mov", mimeType: "application/octet-stream" },
+ { ...file, name: "voice.mp3", mimeType: "audio/mpeg" },
+ { ...file, type: "future" },
+ ];
+ expect(resolveUserMessageFileCards({ text: "", attachments: [] })).toBeNull();
+ for (const attachment of media) {
+ expect(resolveUserMessageFileCards({ text: "", attachments: [attachment] })).toBeNull();
+ expect(resolveUserMessageFileCards({ text: "", attachments: [file, attachment] })).toBeNull();
+ }
+ });
+});
describe("resolveUserMessagePresentation", () => {
const legacyText = "[Triggered by schedule task: Daily audit]\n\nCheck for crashes.\n";
diff --git a/packages/client-runtime/src/userMessage.ts b/packages/client-runtime/src/userMessage.ts
index 8a80f31b155d0..a860c0188b9d2 100644
--- a/packages/client-runtime/src/userMessage.ts
+++ b/packages/client-runtime/src/userMessage.ts
@@ -1,11 +1,21 @@
import {
+ type ChatAttachment,
+ type ChatFileAttachment,
type GuestMessageAttribution,
+ type OrchestrationMessageContext,
type OrchestrationV2Actor,
type OrchestrationV2CreationSource,
type OrchestrationV2IdleCompaction,
+ type OrchestrationV2UserMessageInputIntent,
ScheduledTaskId,
} from "@t3tools/contracts";
-import { isAttachmentOnlyBootstrapPrompt } from "@t3tools/shared/composerContextReferences";
+import {
+ isAttachmentOnlyBootstrapPrompt,
+ replaceComposerContextReferences,
+} from "@t3tools/shared/composerContextReferences";
+import { filePreviewKind } from "@t3tools/shared/filePreview";
+import { imageMimeType } from "@t3tools/shared/image";
+import { videoMimeType } from "@t3tools/shared/video";
/** The working row while T3 Code's own compaction runs. */
export const IDLE_COMPACTING_LABELS = {
@@ -22,6 +32,32 @@ export const IDLE_COMPACTION_TITLES = {
const LEGACY_AUTOMATION_PREFIX = /^\[Triggered by schedule task: [^\r\n]+\]\r?\n\r?\n/;
const LEGACY_AUTOMATION_MESSAGE_ID = /^scheduled-task-message:(.+):\d+:(?:scheduled|manual)$/;
+export function resolveUserMessageFileCards(message: {
+ readonly text: string;
+ readonly attachments: ReadonlyArray;
+ readonly context?: OrchestrationMessageContext | undefined;
+}): ReadonlyArray | null {
+ const files = message.attachments.filter(
+ (attachment): attachment is ChatFileAttachment =>
+ attachment.type === "file" &&
+ imageMimeType(attachment) === null &&
+ videoMimeType(attachment) === null &&
+ filePreviewKind(attachment) !== "audio",
+ );
+ if (files.length === 0 || files.length !== message.attachments.length) return null;
+ const fileIds = new Set(files.map((file) => file.id));
+ const remaining = replaceComposerContextReferences(message.text, (reference) => {
+ const record = message.context?.records.find((item) => item.contextId === reference.contextId);
+ return reference.kind === "file" &&
+ record?.kind === "file" &&
+ "attachmentId" in record &&
+ fileIds.has(record.attachmentId)
+ ? ""
+ : reference.label || reference.kind;
+ });
+ return remaining.trim() === "" ? files : null;
+}
+
export function resolveUserMessagePresentation(message: {
readonly id?: string;
readonly role: string;
@@ -80,3 +116,24 @@ export function resolveUserMessagePresentation(message: {
scheduledTaskId: undefined,
};
}
+
+type GroupableUserMessage = Parameters[0] & {
+ readonly inputIntent?: OrchestrationV2UserMessageInputIntent;
+};
+
+export function resolveUserMessageGrouping(
+ message: GroupableUserMessage | undefined,
+ previous: GroupableUserMessage | undefined,
+ next: GroupableUserMessage | undefined,
+) {
+ const isOwnMessage = (value: GroupableUserMessage | undefined) =>
+ value?.role === "user" && resolveUserMessagePresentation(value).attribution === null;
+ const isSteer = (value: GroupableUserMessage | undefined) =>
+ value?.inputIntent === "steer" || value?.inputIntent === "promoted_queued_to_steer";
+ const groupedWithPrevious = isOwnMessage(message) && isOwnMessage(previous);
+ return {
+ groupedWithPrevious,
+ groupedWithNext: isOwnMessage(message) && isOwnMessage(next),
+ continuesSteer: groupedWithPrevious && isSteer(message) && isSteer(previous),
+ };
+}
diff --git a/packages/contracts/src/agentSessions.ts b/packages/contracts/src/agentSessions.ts
index a60d702d9a0e3..93e0e36e4fbd4 100644
--- a/packages/contracts/src/agentSessions.ts
+++ b/packages/contracts/src/agentSessions.ts
@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
import { IsoDateTime, NonNegativeInt, ProjectId, TrimmedNonEmptyString } from "./baseSchemas.ts";
import { ProviderInstanceId } from "./providerInstance.ts";
-export const AgentSessionSource = Schema.Literals(["claudeAgent", "codex"]);
+export const AgentSessionSource = Schema.Literals(["claudeAgent", "codex", "pi"]);
export type AgentSessionSource = typeof AgentSessionSource.Type;
export const AgentSessionImportSource = Schema.Struct({
diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.ts
index 3cce0127b021e..4f4e04f4a9a83 100644
--- a/packages/contracts/src/ipc.ts
+++ b/packages/contracts/src/ipc.ts
@@ -1047,6 +1047,7 @@ export interface DesktopBridge {
setNotificationBadge: (badge: { count: number; image: string | null }) => Promise;
onNotificationBadgeClear: (listener: () => void) => () => void;
setDockMood?: (mood: DesktopMascotMood) => Promise;
+ onTrackpadScrollBegin: (listener: () => void) => () => void;
onTrackpadScrollEnd: (listener: () => void) => () => void;
/**
* Renderer `window.focus()` cannot raise an Electron window, and on Wayland
diff --git a/packages/contracts/src/relay.ts b/packages/contracts/src/relay.ts
index 4dbb6a199f472..8ebc9df23a0bb 100644
--- a/packages/contracts/src/relay.ts
+++ b/packages/contracts/src/relay.ts
@@ -981,6 +981,8 @@ export const RelayT3ChatLinkResponse = Schema.Struct({
// False when this relay has no T3 Chat secret, so clients hide the feature.
available: Schema.Boolean,
link: Schema.NullOr(RelayT3ChatLink),
+ // A manual cap that replaces the plan's; T3 Chat upgrades do not raise it.
+ maxTunnelsOverride: Schema.optionalKey(Schema.Number),
});
export type RelayT3ChatLinkResponse = typeof RelayT3ChatLinkResponse.Type;
diff --git a/packages/contracts/src/review.ts b/packages/contracts/src/review.ts
index 5a95442917c9a..a40bddfc1e33e 100644
--- a/packages/contracts/src/review.ts
+++ b/packages/contracts/src/review.ts
@@ -6,18 +6,41 @@ import { VcsError } from "./vcs.ts";
export const ReviewDiffPreviewInput = Schema.Struct({
cwd: TrimmedNonEmptyString,
baseRef: Schema.optional(TrimmedNonEmptyString),
+ commitSha: Schema.optional(TrimmedNonEmptyString),
ignoreWhitespace: Schema.optionalKey(Schema.Boolean),
file: Schema.optionalKey(
Schema.Struct({
path: Schema.NonEmptyString,
previousPath: Schema.NullOr(Schema.NonEmptyString),
- sourceKind: Schema.Literals(["working-tree", "branch-range"]),
+ sourceKind: Schema.Literals(["working-tree", "branch-range", "commit"]),
}),
),
});
export type ReviewDiffPreviewInput = typeof ReviewDiffPreviewInput.Type;
-export const ReviewDiffPreviewSourceKind = Schema.Literals(["working-tree", "branch-range"]);
+export const ReviewBranchCommitsInput = Schema.Struct({
+ cwd: TrimmedNonEmptyString,
+ baseRef: Schema.optional(TrimmedNonEmptyString),
+});
+export type ReviewBranchCommitsInput = typeof ReviewBranchCommitsInput.Type;
+
+export const ReviewBranchCommitsResult = Schema.Struct({
+ commits: Schema.Array(
+ Schema.Struct({
+ sha: Schema.String,
+ subject: Schema.String,
+ committedAt: Schema.String,
+ }),
+ ),
+ truncated: Schema.Boolean,
+});
+export type ReviewBranchCommitsResult = typeof ReviewBranchCommitsResult.Type;
+
+export const ReviewDiffPreviewSourceKind = Schema.Literals([
+ "working-tree",
+ "branch-range",
+ "commit",
+]);
export type ReviewDiffPreviewSourceKind = typeof ReviewDiffPreviewSourceKind.Type;
export const ReviewDiffFileStat = Schema.Struct({
@@ -32,6 +55,7 @@ export const ReviewDiffPreviewSource = Schema.Struct({
id: TrimmedNonEmptyString,
kind: ReviewDiffPreviewSourceKind,
title: TrimmedNonEmptyString,
+ commitSubject: Schema.optionalKey(TrimmedNonEmptyString),
baseRef: Schema.NullOr(TrimmedNonEmptyString),
headRef: Schema.NullOr(TrimmedNonEmptyString),
diff: Schema.String,
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index f9ab82d790d6a..a58e72425d0b1 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -157,6 +157,8 @@ import {
VcsStatusStreamEvent,
} from "./git.ts";
import {
+ ReviewBranchCommitsInput,
+ ReviewBranchCommitsResult,
ReviewDiffFileContentsInput,
ReviewDiffFileContentsResult,
ReviewDiffPreviewError,
@@ -470,6 +472,7 @@ export const WS_METHODS = {
gitResolvePullRequest: "git.resolvePullRequest",
gitPreparePullRequestThread: "git.preparePullRequestThread",
+ reviewGetBranchCommits: "review.getBranchCommits",
reviewGetDiffPreview: "review.getDiffPreview",
reviewGetDiffFileContents: "review.getDiffFileContents",
@@ -1532,6 +1535,12 @@ const WsVcsInitRpc = Rpc.make(WS_METHODS.vcsInit, {
error: Schema.Union([VcsError, EnvironmentAuthorizationError]),
});
+const WsReviewGetBranchCommitsRpc = Rpc.make(WS_METHODS.reviewGetBranchCommits, {
+ payload: ReviewBranchCommitsInput,
+ success: ReviewBranchCommitsResult,
+ error: Schema.Union([ReviewDiffPreviewError, EnvironmentAuthorizationError]),
+});
+
const WsReviewGetDiffPreviewRpc = Rpc.make(WS_METHODS.reviewGetDiffPreview, {
payload: ReviewDiffPreviewInput,
success: ReviewDiffPreviewResult,
@@ -2126,6 +2135,7 @@ export const WsRpcGroup = RpcGroup.make(
WsVcsCreateRefRpc,
WsVcsSwitchRefRpc,
WsVcsInitRpc,
+ WsReviewGetBranchCommitsRpc,
WsReviewGetDiffPreviewRpc,
WsReviewGetDiffFileContentsRpc,
WsTerminalOpenRpc,
diff --git a/packages/provider-core/src/server/ProviderAdapter.ts b/packages/provider-core/src/server/ProviderAdapter.ts
index 0b5459f647f8d..cadf4173a60b1 100644
--- a/packages/provider-core/src/server/ProviderAdapter.ts
+++ b/packages/provider-core/src/server/ProviderAdapter.ts
@@ -119,6 +119,14 @@ export const ProviderAdapterV2Event = Schema.Union([
driver: ProviderDriverKind,
turnItem: OrchestrationV2TurnItem,
}),
+ // Start before the root terminal; clear only after the final covered projection.
+ // Consumer lifetime cannot depend on a producer probe that runs ahead of its queue.
+ Schema.Struct({
+ type: Schema.Literal("background_work.updated"),
+ driver: ProviderDriverKind,
+ providerTurnId: ProviderTurnId,
+ pending: Schema.Boolean,
+ }),
/** Unpersisted deltas go only to clients showing the row; final output arrives in turn_item.updated. */
Schema.Struct({
type: Schema.Literal("command_output.delta"),
diff --git a/packages/provider-core/src/server/threadTitleContext.test.ts b/packages/provider-core/src/server/threadTitleContext.test.ts
index 449b3abcdf6cb..253f167c639c0 100644
--- a/packages/provider-core/src/server/threadTitleContext.test.ts
+++ b/packages/provider-core/src/server/threadTitleContext.test.ts
@@ -1,7 +1,30 @@
import { describe, expect, it } from "vite-plus/test";
+import { ChatAttachmentId } from "@t3tools/contracts";
+import { ATTACHMENT_ONLY_BOOTSTRAP_PROMPT } from "@t3tools/shared/composerContextReferences";
import { formatThreadTitleContext } from "./threadTitleContext.ts";
describe("thread title context", () => {
+ it.each(["", "Ultrathink:\n"])("keeps attachments without bootstrap text (%j)", (prefix) => {
+ const attachments = [
+ {
+ type: "image" as const,
+ id: ChatAttachmentId.make("diagram"),
+ name: "diagram.png",
+ mimeType: "image/png",
+ sizeBytes: 10,
+ },
+ ];
+ const text = prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT;
+ expect(formatThreadTitleContext([{ role: "user", text, attachments }])).toEqual({
+ message: "USER:\n[Attachments: diagram.png]",
+ attachments,
+ });
+ expect(formatThreadTitleContext([{ role: "user", text }])).toEqual({
+ message: "",
+ attachments: [],
+ });
+ });
+
it("keeps a user's scope change despite long assistant output", () => {
const result = formatThreadTitleContext([
{ role: "user", text: "Review QR sharing" },
diff --git a/packages/provider-core/src/server/threadTitleContext.ts b/packages/provider-core/src/server/threadTitleContext.ts
index 7d188a4a39de0..f1840891e96bb 100644
--- a/packages/provider-core/src/server/threadTitleContext.ts
+++ b/packages/provider-core/src/server/threadTitleContext.ts
@@ -1,5 +1,6 @@
import type { ChatAttachment } from "@t3tools/contracts";
import { assistantCitationsToPlainText } from "@t3tools/shared/assistantCitations";
+import { isAttachmentOnlyBootstrapPrompt } from "@t3tools/shared/composerContextReferences";
export type ThreadTitleMessage = {
readonly role: "user" | "assistant" | "system" | "reasoning";
@@ -22,7 +23,8 @@ export function limitTitleMessage(text: string, budget: number): string {
}
export function formatThreadTitleContext(messages: ReadonlyArray) {
- const sections = messages.flatMap((message, index) => {
+ const sections = messages.flatMap((source, index) => {
+ const message = isAttachmentOnlyBootstrapPrompt(source.text) ? { ...source, text: "" } : source;
// Thinking traces dwarf answers without identifying the thread subject.
if (
message.role === "system" ||
diff --git a/packages/provider-pi/src/server/adapter.test.ts b/packages/provider-pi/src/server/adapter.test.ts
index 544ac5cce66a3..56754c30923bd 100644
--- a/packages/provider-pi/src/server/adapter.test.ts
+++ b/packages/provider-pi/src/server/adapter.test.ts
@@ -169,6 +169,12 @@ interface FakePi {
readonly vetoNextNewSession: () => void;
readonly allRequests: () => ReadonlyArray;
readonly queueStats: (data: unknown) => void;
+ /** Pi before 0.84.4 answers clear_queue as an unknown command. */
+ readonly setClearQueue: (
+ result:
+ | { readonly steering: ReadonlyArray; readonly followUp: ReadonlyArray }
+ | "unknown_command",
+ ) => void;
readonly closeStdout: Effect.Effect;
readonly lastSpawn: () => {
readonly args: ReadonlyArray;
@@ -208,6 +214,7 @@ const makeFakePi: Effect.Effect = Effect.gen(function* () {
let sessionGeneration = 0;
let models: ReadonlyArray = [];
let isStreaming: boolean | null = null;
+ let clearQueue: Parameters[0] = { steering: [], followUp: [] };
let stdinBuffer = "";
const emit = (record: PiRpcRecord, chunkBytes?: number) =>
@@ -273,6 +280,10 @@ const makeFakePi: Effect.Effect = Effect.gen(function* () {
return { ...base, data: statsQueue.shift() ?? {} };
case "fork":
return { ...base, data: { text: "Hello pi", cancelled: false } };
+ case "clear_queue":
+ return clearQueue === "unknown_command"
+ ? { ...base, success: false, error: "Unknown command: clear_queue" }
+ : { ...base, data: clearQueue };
default:
return base;
}
@@ -386,6 +397,9 @@ const makeFakePi: Effect.Effect = Effect.gen(function* () {
isStreaming = streaming;
},
queueStats: (data) => statsQueue.push(data),
+ setClearQueue: (result) => {
+ clearQueue = result;
+ },
closeStdout: Queue.end(stdout),
lastSpawn: () => lastSpawn,
} satisfies FakePi;
@@ -2027,6 +2041,69 @@ describe("PiAdapterV2", () => {
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
+ it.effect("nests tools called through another tool under their caller", () =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "agent_start" });
+ const takeToolEvents = Effect.fnUntraced(function* (toolCallId: string) {
+ const node = yield* takeEvent(
+ (event) =>
+ event.type === "node.updated" && event.node.nativeItemRef?.nativeId === toolCallId,
+ );
+ const item = yield* takeEvent(
+ (event) =>
+ event.type === "turn_item.updated" &&
+ event.turnItem.nativeItemRef?.nativeId === toolCallId,
+ );
+ if (node.type !== "node.updated" || item.type !== "turn_item.updated")
+ return yield* Effect.die("Expected tool node and item events");
+ return { node: node.node, item: item.turnItem };
+ });
+
+ yield* fake.emit({
+ type: "tool_execution_start",
+ toolCallId: "call_code",
+ toolName: "codemode",
+ args: { code: "await read({ path: 'a.ts' })" },
+ });
+ const caller = yield* takeToolEvents("call_code");
+ assert.equal(caller.node.parentNodeId, caller.node.rootNodeId);
+ assert.isNull(caller.item.parentItemId);
+
+ // Pi tags every phase, so an update that arrives before its start still nests.
+ const phases = [
+ { type: "tool_execution_update", partialResult: { content: [] }, status: "running" },
+ { type: "tool_execution_start", args: { path: "a.ts" }, status: "running" },
+ {
+ type: "tool_execution_end",
+ isError: true,
+ result: { content: [{ type: "text", text: "ENOENT" }] },
+ status: "failed",
+ },
+ ] as const;
+ for (const { status, ...phase } of phases) {
+ yield* fake.emit({
+ ...phase,
+ toolCallId: "call_code/1",
+ toolName: "read",
+ parentToolCallId: "call_code",
+ });
+ const nested = yield* takeToolEvents("call_code/1");
+ assert.equal(nested.node.status, status);
+ assert.equal(nested.node.parentNodeId, caller.node.id);
+ assert.equal(nested.item.parentItemId, caller.item.id);
+ }
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
it.effect(
"keeps native and MCP images available to the shared asset reader with typed results",
() =>
@@ -3876,6 +3953,61 @@ describe("PiAdapterV2", () => {
}).pipe(Effect.scoped, Effect.provide(layerTest)),
);
+ it.effect.each([
+ {
+ pi: "clears its native queue",
+ clearQueue: { steering: ["Use the other file", ""], followUp: ["Then summarize"] },
+ notices: [
+ "Stop cleared 3 queued messages Pi had not read:\n\nUse the other file\n\nThen summarize",
+ ],
+ },
+ { pi: "predates clear_queue", clearQueue: "unknown_command", notices: [] },
+ ] as const)("Stop aborts and retires Pi when it $pi", ({ clearQueue, notices }) =>
+ Effect.gen(function* () {
+ const fake = yield* makeFakePi;
+ fake.setClearQueue(clearQueue);
+ const { runtime, takeEvent } = yield* openRuntime(fake);
+ const providerThread = yield* runtime.ensureThread({
+ threadId: THREAD_ID,
+ modelSelection: modelSelection("default"),
+ runtimePolicy,
+ });
+ yield* startTurn(runtime, providerThread);
+ yield* fake.takeRequest("prompt");
+ yield* fake.emit({ type: "agent_start" });
+ const runningTurn = yield* takeEvent(
+ (event) =>
+ event.type === "provider_turn.updated" && event.providerTurn.status === "running",
+ );
+ const providerTurnId =
+ runningTurn.type === "provider_turn.updated" ? runningTurn.providerTurn.id : undefined;
+ assert.isDefined(providerTurnId);
+
+ yield* runtime.interruptTurn({
+ providerThread,
+ providerTurnId: providerTurnId!,
+ requestRuntimeRestart: true,
+ });
+ yield* fake.takeRequest("abort");
+ assert.deepEqual(
+ fake
+ .allRequests()
+ .map((request) => request["type"])
+ .filter((type) => type === "clear_queue" || type === "abort"),
+ ["clear_queue", "abort"],
+ );
+ const emitted: Array = [];
+ yield* takeEvent((event) => {
+ if (event.type === "turn_item.updated" && event.turnItem.type === "system_notice")
+ emitted.push(event.turnItem.message);
+ return (
+ event.type === "provider_session.updated" && event.providerSession.status === "stopped"
+ );
+ });
+ assert.deepEqual>(emitted, notices);
+ }).pipe(Effect.scoped, Effect.provide(layerTest)),
+ );
+
it.effect("stops active retry progress when the turn is interrupted", () =>
Effect.gen(function* () {
const fake = yield* makeFakePi;
diff --git a/packages/provider-pi/src/server/adapter.ts b/packages/provider-pi/src/server/adapter.ts
index aca13e35643ed..f1924e7639202 100644
--- a/packages/provider-pi/src/server/adapter.ts
+++ b/packages/provider-pi/src/server/adapter.ts
@@ -729,6 +729,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
nativeItemId: string,
startedAt: DateTime.Utc,
updatedAt: DateTime.Utc,
+ parentNativeItemId?: string,
) => ({
id: idAllocator.derive.turnItemFromProviderItem({
driver: PI_PROVIDER,
@@ -743,7 +744,13 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
providerThreadId: turn.turnInput.providerThread.id,
providerTurnId: turn.providerTurn.id,
nativeItemRef: providerRef(nativeItemId),
- parentItemId: null,
+ parentItemId:
+ parentNativeItemId === undefined
+ ? null
+ : idAllocator.derive.turnItemFromProviderItem({
+ driver: PI_PROVIDER,
+ nativeItemId: parentNativeItemId,
+ }),
ordinal: itemOrdinal(turn, nativeItemId),
startedAt,
updatedAt,
@@ -756,6 +763,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
status: OrchestrationV2ExecutionNode["status"],
startedAt: DateTime.Utc,
completedAt: DateTime.Utc | null,
+ parentNativeItemId?: string,
) =>
emit({
type: "node.updated",
@@ -767,7 +775,13 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
}),
threadId: turn.turnInput.threadId,
runId: turn.turnInput.runId,
- parentNodeId: turn.turnInput.rootNodeId,
+ parentNodeId:
+ parentNativeItemId === undefined
+ ? turn.turnInput.rootNodeId
+ : idAllocator.derive.nodeFromProviderItem({
+ driver: PI_PROVIDER,
+ nativeItemId: parentNativeItemId,
+ }),
rootNodeId: turn.turnInput.rootNodeId,
kind,
status,
@@ -980,6 +994,8 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
) {
const toolCallId = recordString(event, "toolCallId");
const toolName = recordString(event, "toolName") ?? "tool";
+ // Pi tags every phase of a call made through ctx.executeTool, such as from a codemode script.
+ const parentToolCallId = recordString(event, "parentToolCallId");
if (toolCallId === undefined) return;
if (phase === "start") {
turn.toolArgs.set(toolCallId, event["args"]);
@@ -999,7 +1015,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
: "failed"
: "completed"
: "running";
- const base = baseItemFields(turn, toolCallId, startedAt, emittedAt);
+ const base = baseItemFields(turn, toolCallId, startedAt, emittedAt, parentToolCallId);
yield* emitItemNode(
turn,
toolCallId,
@@ -1007,6 +1023,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
status,
startedAt,
completed ? emittedAt : null,
+ parentToolCallId,
);
const shared = {
...base,
@@ -1212,6 +1229,59 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
});
});
+ const emitSystemNotice = Effect.fnUntraced(function* (
+ turn: ActivePiTurn,
+ nativeItemId: string,
+ message: string,
+ ) {
+ const emittedAt = yield* DateTime.now;
+ yield* emitItemNode(turn, nativeItemId, "system", "completed", emittedAt, emittedAt);
+ yield* emit({
+ type: "turn_item.updated",
+ driver: PI_PROVIDER,
+ turnItem: {
+ ...baseItemFields(turn, nativeItemId, emittedAt, emittedAt),
+ status: "completed",
+ completedAt: emittedAt,
+ title: message,
+ type: "system_notice",
+ message,
+ },
+ });
+ });
+
+ // Abort leaves queued steers and follow-ups for Pi's next prompt, and Pi before 0.86 starts them
+ // as soon as abort lands, so Stop clears them first. Pi before 0.84.4 rejects clear_queue.
+ const clearNativeQueue = Effect.fnUntraced(function* (turn: ActivePiTurn) {
+ const cleared = yield* request({ type: "clear_queue" }, 2_000).pipe(
+ Effect.map((data) =>
+ ["steering", "followUp"].flatMap((key) => {
+ const texts = recordField(data, key);
+ return Array.isArray(texts)
+ ? texts.filter((text): text is string => typeof text === "string")
+ : [];
+ }),
+ ),
+ Effect.orElseSucceed((): ReadonlyArray => []),
+ );
+ if (cleared.length === 0) return;
+ yield* sessionEventPermit.withPermits(1)(
+ threadState?.activeTurn === turn
+ ? emitSystemNotice(
+ turn,
+ `queue-cleared:${turn.providerTurn.id}`,
+ [
+ `Stop cleared ${cleared.length} queued ${cleared.length === 1 ? "message" : "messages"} Pi had not read:`,
+ // Image-only messages come back as empty text.
+ ...cleared.filter((text) => text.length > 0),
+ ]
+ .join("\n\n")
+ .slice(0, 2_000),
+ )
+ : Effect.void,
+ );
+ });
+
const handleExtensionUiRequest = Effect.fnUntraced(function* (event: PiRpcRecord) {
const method = recordString(event, "method");
const nativeRequestId = recordString(event, "id");
@@ -1221,21 +1291,11 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
const turn = state?.activeTurn ?? null;
const message = recordString(event, "message") ?? "";
if (turn === null || message.length === 0) return;
- const emittedAt = yield* DateTime.now;
- const nativeItemId = `notify:${turn.providerTurn.id}:${turn.nextItemOrdinal}`;
- yield* emitItemNode(turn, nativeItemId, "system", "completed", emittedAt, emittedAt);
- yield* emit({
- type: "turn_item.updated",
- driver: PI_PROVIDER,
- turnItem: {
- ...baseItemFields(turn, nativeItemId, emittedAt, emittedAt),
- status: "completed",
- completedAt: emittedAt,
- title: message,
- type: "system_notice",
- message,
- },
- });
+ yield* emitSystemNotice(
+ turn,
+ `notify:${turn.providerTurn.id}:${turn.nextItemOrdinal}`,
+ message,
+ );
return;
}
if (
@@ -2641,6 +2701,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
// Generic abort misses manual compaction; terminate so Stop covers /compact and recovery.
stopRequested = true;
if (interruptInput.requestRuntimeRestart === true && !turn.settleWhenIdle) {
+ yield* clearNativeQueue(turn);
yield* request({ type: "abort" }, 2_000).pipe(Effect.ignore);
}
// Read rollback tree refs before termination breaks requests; the permit lets in-flight capture finish.
@@ -2654,6 +2715,7 @@ export const makePiAdapterV2 = Effect.fn("makePiAdapterV2")(function* (
);
return;
}
+ yield* clearNativeQueue(turn);
yield* request({ type: "abort" }).pipe(
Effect.tapError(() => Effect.sync(() => (turn.interrupted = false))),
);
diff --git a/packages/provider-pi/src/server/mcpExtensionSource.test.ts b/packages/provider-pi/src/server/mcpExtensionSource.test.ts
index b1306f701e27a..cedf3974f535d 100644
--- a/packages/provider-pi/src/server/mcpExtensionSource.test.ts
+++ b/packages/provider-pi/src/server/mcpExtensionSource.test.ts
@@ -25,7 +25,10 @@ type InputHook = (
ctx: { ui: { notify: (message: string, level: string) => void } },
) => Promise<{ action: string; text: string; images?: ReadonlyArray } | undefined>;
-async function loadHooks(commands: ReadonlyArray = []) {
+async function loadHooks(
+ commands: ReadonlyArray = [],
+ argv: ReadonlyArray = [],
+) {
const handlers = new Map();
const source = NodeModule.stripTypeScriptTypes(
PI_T3_MCP_EXTENSION_SOURCE.replace(/^import .*;$/gm, "").replace(
@@ -34,7 +37,7 @@ async function loadHooks(commands: ReadonlyArray = []) {
),
);
await NodeVM.runInNewContext(`${source}\nt3McpExtension(pi)`, {
- process: { env: {} },
+ process: { env: {}, argv },
NodeFSP,
NodePath,
stripFrontmatter: (content: string) => content,
@@ -77,6 +80,32 @@ describe("Pi orchestration prompt section", () => {
});
});
+describe("Pi project trust", () => {
+ it.each([
+ { name: "a trusted folder", trusted: true, argv: [], notices: 0 },
+ { name: "an untrusted folder", trusted: false, argv: [], notices: 1 },
+ { name: "--no-approve", trusted: false, argv: ["--approve", "-na"], notices: 0 },
+ ])("sends $notices trust notice per session for $name", async ({ trusted, argv, notices }) => {
+ const sent: string[] = [];
+ const ctx = {
+ cwd: "/repo",
+ isProjectTrusted: () => trusted,
+ ui: { notify: (message: string) => sent.push(message) },
+ };
+ // Pi reruns extension factories on session replacement without asking about trust again.
+ for (const _session of [1, 2]) {
+ const handlers = (await loadHooks([], ["node", "pi", ...argv])) as Map<
+ string,
+ (event: unknown, ctx: unknown) => unknown
+ >;
+ for (const _turn of [1, 2]) await handlers.get("before_agent_start")!({}, ctx);
+ }
+ assert.equal(sent.length, notices * 2);
+ for (const message of sent)
+ assert.include(message, "for /repo because the folder is not trusted");
+ });
+});
+
describe("Pi MCP tool results", () => {
it("returns mixed screenshot blocks and typed script output without repeating structured text", async () => {
const content = [
diff --git a/packages/provider-pi/src/server/mcpExtensionSource.ts b/packages/provider-pi/src/server/mcpExtensionSource.ts
index dcc4a0230a8db..ee72c38f75966 100644
--- a/packages/provider-pi/src/server/mcpExtensionSource.ts
+++ b/packages/provider-pi/src/server/mcpExtensionSource.ts
@@ -241,6 +241,20 @@ function createMcpClient(endpoint: string, token: string) {
}
export default async function t3McpExtension(pi: ExtensionAPI) {
+ // RPC has no trust prompt, so Pi skips an untrusted folder's protected resources. Session
+ // replacement reruns this factory without project_trust, and T3 drops notices outside a turn,
+ // so check each session's first turn. An explicit --no-approve is deliberate and stays quiet.
+ let projectTrustChecked = false;
+ pi.on("before_agent_start", (_event, ctx) => {
+ if (projectTrustChecked) return;
+ projectTrustChecked = true;
+ if (ctx.isProjectTrusted() || process.argv.some((arg) => arg === "--no-approve" || arg === "-na")) return;
+ ctx.ui.notify(
+ \`Pi did not load project settings, extensions, skills, prompts, MCP servers or system prompt files for \${ctx.cwd} because the folder is not trusted. To load them, run the configured Pi binary there with the same PI_CODING_AGENT_DIR (if set), trust the folder or its parent with /trust, then start a new thread in that same worktree. To trust every project, add --approve to Pi's launch arguments in T3 Code settings; to keep them off without this notice, add --no-approve.\`,
+ "warning",
+ );
+ });
+
// Keep skill chips in the request. Pi expands only one leading /skill:
// command, so use its own frontmatter loader for every selected chip here.
pi.on("input", async (event, ctx) => {
diff --git a/packages/provider-pi/src/server/status.test.ts b/packages/provider-pi/src/server/status.test.ts
index cee6442fc9642..b8559d1ab7d8a 100644
--- a/packages/provider-pi/src/server/status.test.ts
+++ b/packages/provider-pi/src/server/status.test.ts
@@ -52,7 +52,15 @@ function piProbeSpawner(version: string) {
});
}
-const piDiscoverySpawner = (inventory: unknown) =>
+/** Fails the test if status runs `pi auth check` without `authCheck` or with other arguments. */
+const piDiscoverySpawner = (
+ inventory: unknown,
+ options: {
+ readonly version?: string;
+ readonly state?: unknown;
+ readonly authCheck?: string | undefined;
+ } = {},
+) =>
Effect.gen(function* () {
const stdout = yield* Queue.unbounded();
let stdinBuffer = "";
@@ -71,7 +79,9 @@ const piDiscoverySpawner = (inventory: unknown) =>
? inventory
: request.type === "get_commands"
? { commands: [] }
- : {};
+ : request.type === "get_state"
+ ? (options.state ?? {})
+ : {};
yield* Queue.offer(
stdout,
encoder.encode(
@@ -83,16 +93,23 @@ const piDiscoverySpawner = (inventory: unknown) =>
);
return ChildProcessSpawner.make((command) => {
const args = ChildProcess.isStandardCommand(command) ? command.args : [];
+ if (args.includes("--version")) {
+ return Effect.succeed(processHandle({ stdout: `pi ${options.version ?? "0.84.3"}\n` }));
+ }
+ if (args[0] === "auth") {
+ const expected = ["auth", "check", "--provider", "openai", "--json", "--no-refresh"];
+ return options.authCheck === undefined || args.join(" ") !== expected.join(" ")
+ ? Effect.die(`Unexpected pi ${args.join(" ")}`)
+ : Effect.succeed(processHandle({ stdout: options.authCheck, exitCode: 1 }));
+ }
return Effect.succeed(
- args.includes("--version")
- ? processHandle({ stdout: "pi 0.84.3\n" })
- : ChildProcessSpawner.makeHandle({
- ...processHandle({}),
- exitCode: Effect.never,
- isRunning: Effect.succeed(true),
- stdin,
- stdout: Stream.fromQueue(stdout),
- }),
+ ChildProcessSpawner.makeHandle({
+ ...processHandle({}),
+ exitCode: Effect.never,
+ isRunning: Effect.succeed(true),
+ stdin,
+ stdout: Stream.fromQueue(stdout),
+ }),
);
});
});
@@ -146,6 +163,72 @@ describe("PiProvider", () => {
}).pipe(Effect.provide(NodeServices.layer)),
);
+ it.effect.each([
+ {
+ label: "a pinned model without credentials",
+ version: "1.4.0",
+ activeModel: { provider: "openai", id: "gpt-5" },
+ authCheck: '{"status":"not_ready","provider":"openai","reason":"credentials_not_configured"}',
+ message: "Pi default (openai/gpt-5) has no credentials configured for openai.",
+ },
+ {
+ label: "a pinned model with a runtime --api-key",
+ version: "1.4.0",
+ launchArgs: "--provider openai --model gpt-5 --api-key fake-key",
+ activeModel: { provider: "openai", id: "gpt-5" },
+ authCheck: undefined,
+ message: "Pi default (openai/gpt-5) uses openai, which has no available models in Pi.",
+ },
+ {
+ label: "a pinned model whose provider auth check cannot find",
+ version: "1.4.0",
+ activeModel: { provider: "openai", id: "gpt-5" },
+ authCheck: '{"status":"not_ready","provider":"openai","reason":"provider_not_found"}',
+ message: "Pi default (openai/gpt-5) uses openai, which has no available models in Pi.",
+ },
+ {
+ label: "a pinned model on Pi without auth check",
+ version: MINIMUM_PI_VERSION,
+ activeModel: { provider: "openai", id: "gpt-5" },
+ authCheck: undefined,
+ message: "Pi default (openai/gpt-5) uses openai, which has no available models in Pi.",
+ },
+ {
+ label: "an uncatalogued model id of a provider with credentials",
+ version: "1.4.0",
+ activeModel: { provider: "anthropic", id: "claude-next" },
+ authCheck: undefined,
+ message: undefined,
+ },
+ {
+ label: "an extension model Pi lists as available",
+ version: "1.4.0",
+ activeModel: { provider: "router", id: "auto" },
+ authCheck: undefined,
+ message: undefined,
+ },
+ ])("diagnoses Pi's active model readiness for $label", (row) =>
+ Effect.gen(function* () {
+ const spawner = yield* piDiscoverySpawner(
+ {
+ models: [
+ { provider: "anthropic", id: "claude-sonnet-4" },
+ { provider: "router", id: "auto" },
+ ],
+ },
+ { version: row.version, state: { model: row.activeModel }, authCheck: row.authCheck },
+ );
+ const snapshot = yield* checkPiProviderStatus({
+ ...settings,
+ launchArgs: row.launchArgs ?? "",
+ }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
+ assert.equal(snapshot.status, "ready");
+ assert.equal(snapshot.auth.status, "authenticated");
+ if (row.message === undefined) assert.isUndefined(snapshot.message);
+ else assert.include(snapshot.message ?? "", row.message);
+ }).pipe(Effect.provide(NodeServices.layer)),
+ );
+
// regression: #18498 a malformed model inventory must not restore stale Pi models
it.effect.each([
["missing models", {}],
diff --git a/packages/provider-pi/src/server/status.ts b/packages/provider-pi/src/server/status.ts
index eef8bb5be3552..a180ab9c41a3b 100644
--- a/packages/provider-pi/src/server/status.ts
+++ b/packages/provider-pi/src/server/status.ts
@@ -13,6 +13,7 @@ import * as Stream from "effect/Stream";
import * as Exit from "effect/Exit";
import * as Option from "effect/Option";
import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
import * as HttpClient from "effect/http/HttpClient";
import * as ChildProcess from "effect/process/ChildProcess";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
@@ -62,6 +63,12 @@ const PI_RPC_DISCOVERY_TIMEOUT_MS = 30_000;
* Version 0.80.5 was the first published package containing both hooks.
*/
export const MINIMUM_PI_VERSION = "0.80.5";
+/** `pi auth check --json --no-refresh` arrived in 0.84.1. */
+const PI_AUTH_CHECK_VERSION = "0.84.1";
+
+const decodePiAuthCheck = Schema.decodeUnknownOption(
+ Schema.fromJsonString(Schema.Struct({ reason: Schema.optional(Schema.String) })),
+);
const PI_DEFAULT_MODEL: ServerProviderModel = {
slug: "default",
@@ -73,6 +80,8 @@ const PI_DEFAULT_MODEL: ServerProviderModel = {
interface PiDiscovery extends PiDiscoveredCommands {
readonly models: ReadonlyArray;
readonly authenticated: boolean;
+ /** Pi's active model when Pi lists no model of its provider, so it cannot start a turn. */
+ readonly unavailableActiveModel: { readonly provider: string; readonly id: string } | undefined;
}
function piModelsFromSettings(
@@ -169,11 +178,22 @@ const discoverPiViaRpc = Effect.fn("PiProviderStatus.discoverPiViaRpc")(function
.pipe(Effect.orElseSucceed(() => undefined));
const discoveredModels = yield* Effect.fromResult(parseDiscoveredModels(modelsData, stateData));
const { slashCommands, skills } = parsePiDiscoveredCommands(commandsData);
+ // Pi lists only models of providers it holds credentials for, including extension, virtual and
+ // --api-key ones. Turns need only the provider's credentials, so uncatalogued model ids still run.
+ const activeModel = recordField(stateData, "model");
+ const activeProvider = recordString(activeModel, "provider");
+ const activeModelId = recordString(activeModel, "id");
return {
models: discoveredModels,
slashCommands: withPiBuiltinSlashCommands(slashCommands),
skills,
authenticated: discoveredModels.length > 0,
+ unavailableActiveModel:
+ activeProvider !== undefined &&
+ activeModelId !== undefined &&
+ !discoveredModels.some((model) => model.subProvider === activeProvider)
+ ? { provider: activeProvider, id: activeModelId }
+ : undefined,
} satisfies PiDiscovery;
}, Effect.scoped);
@@ -221,6 +241,56 @@ const runPiVersionCommand = Effect.fn("PiProviderStatus.runPiVersionCommand")(fu
);
});
+/**
+ * Explains why Pi's active model cannot start a turn. On Pi versions with `auth check`, asks it
+ * whether credentials are missing, without refreshing or printing them. That command cannot see
+ * extension providers or a runtime --api-key, so it only refines Pi's own unavailable verdict,
+ * and is skipped when launch args supply the key.
+ */
+const describeUnavailablePiModel = Effect.fn("PiProviderStatus.describeUnavailablePiModel")(
+ function* (
+ piSettings: PiSettings,
+ environment: NodeJS.ProcessEnv,
+ version: string,
+ launchArgs: ReadonlyArray,
+ model: { readonly provider: string; readonly id: string },
+ ) {
+ const label = `Pi default (${model.provider}/${model.id})`;
+ const unavailable = `${label} uses ${model.provider}, which has no available models in Pi. Choose another model, or check that provider's setup and the Pi launch arguments.`;
+ if (
+ compareSemverVersions(version, PI_AUTH_CHECK_VERSION) < 0 ||
+ launchArgs.includes("--api-key")
+ ) {
+ return unavailable;
+ }
+ const command = piSettings.binaryPath || "pi";
+ const output = yield* resolveSpawnCommand(
+ command,
+ ["auth", "check", "--provider", model.provider, "--json", "--no-refresh"],
+ { env: environment },
+ ).pipe(
+ Effect.flatMap((spawnCommand) =>
+ spawnAndCollect(
+ command,
+ ChildProcess.make(spawnCommand.command, spawnCommand.args, {
+ env: environment,
+ shell: spawnCommand.shell,
+ }),
+ ),
+ ),
+ Effect.timeout(VERSION_PROBE_TIMEOUT_MS),
+ Effect.option,
+ );
+ const missingCredentials = Option.exists(
+ Option.flatMap(output, (result) => decodePiAuthCheck(result.stdout)),
+ (check) => check.reason === "credentials_not_configured",
+ );
+ return missingCredentials
+ ? `${label} has no credentials configured for ${model.provider}. Choose another model, or run \`pi\` in a terminal and use /login or configure its API key.`
+ : unavailable;
+ },
+);
+
export const buildInitialPiProviderSnapshot = Effect.fn(
"PiProviderStatus.buildInitialPiProviderSnapshot",
)(function* (piSettings: PiSettings): Effect.fn.Return {
@@ -432,6 +502,17 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function
const discovery = discoveryExit.value.value;
const models = piModelsFromSettings(piSettings.customModels, discovery.models);
+ const message = !discovery.authenticated
+ ? "Pi has no usable models. Run `pi` in a terminal and use /login, or configure an API key in ~/.pi/agent."
+ : discovery.unavailableActiveModel === undefined
+ ? undefined
+ : yield* describeUnavailablePiModel(
+ piSettings,
+ environment,
+ version,
+ resolvedLaunchArgs.args,
+ discovery.unavailableActiveModel,
+ );
return buildServerProvider({
presentation: PI_PRESENTATION,
enabled: piSettings.enabled,
@@ -442,14 +523,10 @@ export const checkPiProviderStatus = Effect.fn("checkPiProviderStatus")(function
probe: {
installed: true,
version,
+ // Other Pi models still work when only the default is unavailable, so keep the picker usable.
status: discovery.authenticated ? "ready" : "warning",
auth: { status: discovery.authenticated ? "authenticated" : "unauthenticated", type: "pi" },
- ...(discovery.authenticated
- ? {}
- : {
- message:
- "Pi has no usable models. Run `pi` in a terminal and use /login, or configure an API key in ~/.pi/agent.",
- }),
+ ...(message === undefined ? {} : { message }),
},
});
});
diff --git a/packages/provider-pi/src/server/usage.ts b/packages/provider-pi/src/server/usage.ts
index 5dadc93e101d9..961a73e838acd 100644
--- a/packages/provider-pi/src/server/usage.ts
+++ b/packages/provider-pi/src/server/usage.ts
@@ -131,16 +131,21 @@ export const piUsageReader: ProviderUsageReader = {
directories: Effect.fn("piUsageReader.directories")(function* ({ environment }) {
const path = yield* Path.Path;
const home = yield* HostProcess.HomeDirectory;
- const sessionDir = environment.PI_CODING_AGENT_SESSION_DIR?.trim();
- if (sessionDir) return [{ dir: path.resolve(expandHomePath(sessionDir, home)) }];
- const agentDir = environment.PI_CODING_AGENT_DIR?.trim();
- return [
- {
- dir: path.resolve(
- agentDir ? expandHomePath(agentDir, home) : path.join(home, ".pi", "agent"),
- "sessions",
- ),
- },
- ];
+ return [{ dir: resolvePiSessionsDir(environment, home, path) }];
}),
};
+
+/** Where Pi stores session JSONL files for a provider environment, matching Pi's own lookup. */
+export function resolvePiSessionsDir(
+ environment: NodeJS.ProcessEnv,
+ home: string,
+ path: Path.Path,
+): string {
+ const sessionDir = environment.PI_CODING_AGENT_SESSION_DIR?.trim();
+ if (sessionDir) return path.resolve(expandHomePath(sessionDir, home));
+ const agentDir = environment.PI_CODING_AGENT_DIR?.trim();
+ return path.resolve(
+ agentDir ? expandHomePath(agentDir, home) : path.join(home, ".pi", "agent"),
+ "sessions",
+ );
+}
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 0275ebe21a05e..de1266425513c 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -475,6 +475,10 @@
"types": "./src/markdownWindowsPaths.ts",
"import": "./src/markdownWindowsPaths.ts"
},
+ "./generatedImageMarkdown": {
+ "types": "./src/generatedImageMarkdown.ts",
+ "import": "./src/generatedImageMarkdown.ts"
+ },
"./markdownPipeline": {
"types": "./src/markdownPipeline.ts",
"import": "./src/markdownPipeline.ts"
@@ -538,6 +542,7 @@
"mdast-util-to-hast": "^13.2.1",
"micromark-extension-directive": "catalog:",
"micromark-util-character": "catalog:",
+ "property-information": "^7.2.0",
"rehype-raw": "catalog:",
"rehype-sanitize": "catalog:",
"remark-breaks": "catalog:",
diff --git a/packages/shared/src/composerContextReferences.test.ts b/packages/shared/src/composerContextReferences.test.ts
index 7212a1b64a984..7356c525308c2 100644
--- a/packages/shared/src/composerContextReferences.test.ts
+++ b/packages/shared/src/composerContextReferences.test.ts
@@ -7,11 +7,14 @@ import {
import { describe, expect, it } from "vite-plus/test";
import {
+ ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
collectComposerContextReferences,
formatComposerContextHref,
isImageReferencesOnly,
parseComposerContextHref,
projectComposerContextForProvider,
+ restoreAttachmentOnlyBootstrapPrompt,
+ stripAttachmentOnlyBootstrapPrompt,
threadContextRecord,
threadContextsOutsideEnvironment,
toComposerContextId,
@@ -84,6 +87,38 @@ describe("labels and reference links", () => {
});
});
+describe("attachment-only bootstrap prompts", () => {
+ it.each(["", "Ultrathink:\n", "ultrathink: \n"])(
+ "removes only the placeholder while keeping effort (%j)",
+ (prefix) => {
+ expect(stripAttachmentOnlyBootstrapPrompt(prefix + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT)).toBe(
+ prefix.trimEnd(),
+ );
+ const text = `${prefix}Explain ${ATTACHMENT_ONLY_BOOTSTRAP_PROMPT}`;
+ expect(stripAttachmentOnlyBootstrapPrompt(text)).toBe(text);
+ },
+ );
+
+ it.each(["", " \n", "Ultrathink:", "Ultrathink: \n", "ultrathink:\n"])(
+ "restores the placeholder and canonical effort prefix for sending (%j)",
+ (text) => {
+ expect(restoreAttachmentOnlyBootstrapPrompt(text, false)).toBe(text);
+ expect(restoreAttachmentOnlyBootstrapPrompt(text, true)).toBe(
+ (text.trim() ? "Ultrathink:\n" : "") + ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+ );
+ },
+ );
+
+ it.each([
+ "Describe the file",
+ " Ultrathink:\nDescribe the file ",
+ ATTACHMENT_ONLY_BOOTSTRAP_PROMPT,
+ `Ultrathink:\n${ATTACHMENT_ONLY_BOOTSTRAP_PROMPT}`,
+ ])("keeps other text unchanged (%j)", (text) => {
+ expect(restoreAttachmentOnlyBootstrapPrompt(text, true)).toBe(text);
+ });
+});
+
describe("provider projection", () => {
const terminal: ComposerContextRecord = {
version: 1,
diff --git a/packages/shared/src/composerContextReferences.ts b/packages/shared/src/composerContextReferences.ts
index 88361606a9a64..a76145ffddc68 100644
--- a/packages/shared/src/composerContextReferences.ts
+++ b/packages/shared/src/composerContextReferences.ts
@@ -137,6 +137,24 @@ export function isAttachmentOnlyBootstrapPrompt(text: string): boolean {
return text.replace(/^Ultrathink:\s*/i, "") === ATTACHMENT_ONLY_BOOTSTRAP_PROMPT;
}
+export function stripAttachmentOnlyBootstrapPrompt(text: string): string {
+ return isAttachmentOnlyBootstrapPrompt(text)
+ ? text.slice(0, -ATTACHMENT_ONLY_BOOTSTRAP_PROMPT.length).trimEnd()
+ : text;
+}
+
+export function restoreAttachmentOnlyBootstrapPrompt(
+ text: string,
+ hasAttachments: boolean,
+): string {
+ if (!hasAttachments) return text;
+ const trimmed = text.trim();
+ if (trimmed.length === 0) return ATTACHMENT_ONLY_BOOTSTRAP_PROMPT;
+ return /^Ultrathink:\s*$/i.test(trimmed)
+ ? `Ultrathink:\n${ATTACHMENT_ONLY_BOOTSTRAP_PROMPT}`
+ : text;
+}
+
export function isImageReferencesOnly(text: string): boolean {
const references = collectComposerContextReferences(text);
return (
diff --git a/packages/shared/src/filePreview.test.ts b/packages/shared/src/filePreview.test.ts
index b6f4fc940874a..9024954ebf1ad 100644
--- a/packages/shared/src/filePreview.test.ts
+++ b/packages/shared/src/filePreview.test.ts
@@ -30,6 +30,9 @@ describe("workspace file previews", () => {
expect(isWorkspacePreviewEntryPath(`${name}?download=1`)).toBe(false);
expect(hostPreviewMimeTypeFromExtension(`.${extension}`)).toBe(mimeType);
});
+ it("previews a TypeScript file the OS labels as MPEG transport stream as text", () => {
+ expect(filePreviewKind({ name: "clamp.ts", mimeType: "video/mp2t" })).toBe("text");
+ });
it("recognizes compound archives and MIME aliases", () => {
expect(filePreviewKind({ name: "archive.tar.gz" })).toBe("archive");
expect(filePreviewKind({ name: "download", mimeType: "application/x-gzip" })).toBe("archive");
diff --git a/packages/shared/src/filePreview.ts b/packages/shared/src/filePreview.ts
index 4155252a12a90..2cd77e2e59779 100644
--- a/packages/shared/src/filePreview.ts
+++ b/packages/shared/src/filePreview.ts
@@ -9,6 +9,7 @@ export {
mediaKindFromPath,
mediaMimeTypeFromExtension,
} from "./mediaPreview.ts";
+import { GENERIC_MIME_TYPES } from "./image.ts";
import { videoMimeType } from "./video.ts";
export type FilePreviewKind =
@@ -41,7 +42,7 @@ export function filePreviewKind(
const mime = file.mimeType?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
const name = file.name.toLowerCase();
const extension = name.slice(name.lastIndexOf("."));
- const generic = !mime || mime === "application/octet-stream" || mime === "text/plain";
+ const generic = !mime || GENERIC_MIME_TYPES.has(mime) || mime === "text/plain";
const richDocuments = options?.richDocuments !== false;
const office = richDocuments ? officePreviewKind(file) : null;
if (office) return office;
@@ -61,7 +62,7 @@ export function filePreviewKind(
)
return "font";
if (mime.startsWith("image/")) return "image";
- if (mime.startsWith("video/")) return "video";
+ if (mime.startsWith("video/") && !generic) return "video";
if (mime.startsWith("audio/")) return "audio";
if (generic) {
if (extension === ".pdf") return "pdf";
diff --git a/packages/shared/src/generatedImageMarkdown.test.ts b/packages/shared/src/generatedImageMarkdown.test.ts
new file mode 100644
index 0000000000000..4934ee27d24aa
--- /dev/null
+++ b/packages/shared/src/generatedImageMarkdown.test.ts
@@ -0,0 +1,78 @@
+import { expect, it } from "vite-plus/test";
+
+import { appendGeneratedImageEmbeds } from "./generatedImageMarkdown.ts";
+
+it.each([
+ {
+ name: "appends each new image once",
+ text: "Done.",
+ saved: ["/tmp/a.png", "/tmp/b.png", "/tmp/a.png"],
+ expected: "Done.\n\n![]()\n\n![]()",
+ },
+ {
+ name: "skips images the reply already shows",
+ text: String.raw`![A]()  ![C][a\*b] ![D][unc]
+
+[a\*b]: c:\Users\me\.codex\c.png
+[unc]: <\\HOST\Share\d.png>
+
+`,
+ saved: [
+ "/tmp/a b.png",
+ String.raw`C:\Users\Me\.codex\b.png`,
+ String.raw`C:\Users\Me\.codex\c.png`,
+ String.raw`\\host\share\d.png`,
+ String.raw`\\HOST\SHARE\e.png`,
+ "/tmp/C.png",
+ ],
+ expected: String.raw`![A]()  ![C][a\*b] ![D][unc]
+
+[a\*b]: c:\Users\me\.codex\c.png
+[unc]: <\\HOST\Share\d.png>
+
+
+
+![]()`,
+ },
+ {
+ name: "links, code and escaped embeds still need a preview",
+ text: "[open](/tmp/a.png) ``\n\n```md\n\n```\n\\",
+ saved: ["/tmp/a.png"],
+ expected:
+ "[open](/tmp/a.png) ``\n\n```md\n\n```\n\\\n\n![]()",
+ },
+ {
+ name: "an unclosed trailing fence is closed first",
+ text: 'Created.\n\n~~~js\nconsole.log("done");',
+ saved: ["/tmp/a.png"],
+ expected: 'Created.\n\n~~~js\nconsole.log("done");\n~~~\n\n![]()',
+ },
+ {
+ name: "an unclosed trailing HTML comment is closed first",
+ text: "\n\n![]()",
+ },
+ {
+ name: "an unclosed trailing raw HTML block is closed first",
+ text: "\nlog",
+ saved: ["/tmp/a.png"],
+ expected: "\nlog\n
\n\n![]()",
+ },
+ {
+ name: "Windows, UNC and reserved characters keep their path",
+ text: "",
+ saved: [
+ String.raw`C:\Users\me\a b#1.png`,
+ String.raw`\\host\share\a.png`,
+ "/tmp/a#b?100%25©\\!\n.png",
+ ],
+ expected:
+ "![]()\n\n![]()\n\n",
+ },
+])("generated image embeds: $name", ({ text, saved, expected }) => {
+ const result = appendGeneratedImageEmbeds(text, saved);
+ expect(result).toBe(expected);
+ // Clients read every appended embed back as its saved file.
+ expect(appendGeneratedImageEmbeds(result, saved)).toBe(result);
+});
diff --git a/packages/shared/src/generatedImageMarkdown.ts b/packages/shared/src/generatedImageMarkdown.ts
new file mode 100644
index 0000000000000..cf69dab1c3e56
--- /dev/null
+++ b/packages/shared/src/generatedImageMarkdown.ts
@@ -0,0 +1,69 @@
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+
+import { markdownDestinationHostPath } from "./markdownLinks.ts";
+import { chatMarkdownImageSources } from "./markdownPipeline.ts";
+import { isUncPath, isWindowsDrivePath, normalizeProjectPathForComparison } from "./path.ts";
+
+const parser = unified().use(remarkParse);
+
+function imageEmbed(path: string): string {
+ // Forward slashes read the same in every client parser; UNC paths also need file: to
+ // distinguish them from protocol-relative web URLs.
+ const destination = isWindowsDrivePath(path)
+ ? path.replaceAll("\\", "/")
+ : isUncPath(path)
+ ? `file:${path.replaceAll("\\", "/")}`
+ : path;
+ // Clients split `?`/`#`, decode `%` and `&` entities, and read POSIX backslashes as escapes;
+ // line breaks end an angle destination.
+ const escaped = destination.replace(/[%?#&\\\r\n]/g, encodeURIComponent).replace(/[<>]/g, "\\$&");
+ return ``;
+}
+
+// An unclosed fence or raw HTML block swallows the rest of the reply. Only a root-level block
+// can swallow appended embeds; nested ones end with their container.
+function unclosedBlockEnd(text: string): string | undefined {
+ const last = parser.parse(text).children.at(-1);
+ const source = text.slice(last?.position?.start.offset, last?.position?.end.offset);
+ if (last?.type === "html") {
+ const tag = /^ {0,3}<(script|pre|style|textarea)(?=[\s>]|$)/i.exec(source)?.[1];
+ if (tag !== undefined) {
+ return /<\/(?:script|pre|style|textarea)>/i.test(source) ? undefined : ``;
+ }
+ return /^ {0,3}") ? "-->" : undefined;
+ }
+ if (last?.type !== "code") return undefined;
+ const fence = /^ {0,3}(`{3,}|~{3,})/.exec(source)?.[1];
+ if (fence === undefined) return undefined;
+ const lines = source.split(/\r\n|\r|\n/);
+ const closing = /^ {0,3}(`{3,}|~{3,})[\t ]*$/.exec(lines.at(-1) ?? "")?.[1];
+ const closed =
+ lines.length > 1 &&
+ closing !== undefined &&
+ closing[0] === fence[0] &&
+ closing.length >= fence.length;
+ return closed ? undefined : fence;
+}
+
+/** Appends an embed for each saved image the reply does not already show. */
+export function appendGeneratedImageEmbeds(text: string, savedPaths: Iterable): string {
+ const shown = new Set(
+ chatMarkdownImageSources(text).flatMap((source) => {
+ const path = markdownDestinationHostPath(source);
+ return path === null ? [] : [normalizeProjectPathForComparison(path)];
+ }),
+ );
+ const missing = new Map();
+ for (const path of savedPaths) {
+ const key = normalizeProjectPathForComparison(path);
+ if (!shown.has(key) && !missing.has(key)) missing.set(key, path);
+ }
+ if (missing.size === 0) return text;
+ const end = unclosedBlockEnd(text);
+ let result = end === undefined ? text : `${text}${/[\r\n]$/.test(text) ? "" : "\n"}${end}`;
+ for (const path of missing.values()) {
+ result += `${result.length > 0 ? "\n\n" : ""}${imageEmbed(path)}`;
+ }
+ return result;
+}
diff --git a/packages/shared/src/image.ts b/packages/shared/src/image.ts
index 30615c24f967c..3c219286ac234 100644
--- a/packages/shared/src/image.ts
+++ b/packages/shared/src/image.ts
@@ -13,6 +13,9 @@ export const GENERIC_MIME_TYPES = new Set([
"application/octet-stream",
"binary/octet-stream",
"application/unknown",
+ // macOS and Windows label TypeScript `.ts` files as MPEG transport streams, which browsers can't play.
+ "video/mp2t",
+ "video/vnd.dlna.mpeg-tts",
]);
export function isSvgAttachment(attachment: {
diff --git a/packages/shared/src/markdownListIndentation.ts b/packages/shared/src/markdownListIndentation.ts
index 540f3c4742255..f41e6d2eddde2 100644
--- a/packages/shared/src/markdownListIndentation.ts
+++ b/packages/shared/src/markdownListIndentation.ts
@@ -113,6 +113,10 @@ function attachListItemIndentationNormalizer(this: MarkdownParser) {
if (!node.children) {
return;
}
+ if (!node.children.some((child) => isSameLineOverIndentedCode(child, node, source))) {
+ for (const child of node.children) visit(child, source);
+ return;
+ }
node.children = node.children.flatMap((child) => {
if (isSameLineOverIndentedCode(child, node, source)) {
const recovered = blocksFromIndentedCode(child, this);
diff --git a/packages/shared/src/markdownPipeline.test.ts b/packages/shared/src/markdownPipeline.test.ts
index aa753e6303fc0..214f55f8f4273 100644
--- a/packages/shared/src/markdownPipeline.test.ts
+++ b/packages/shared/src/markdownPipeline.test.ts
@@ -1,5 +1,6 @@
import { expect, it } from "vite-plus/test";
import { unified } from "unified";
+import rehypeRaw from "rehype-raw";
import remarkParse from "remark-parse";
import remarkRehype from "remark-rehype";
import { CHAT_MARKDOWN_REHYPE_PLUGINS, CHAT_MARKDOWN_REMARK_PLUGINS } from "./markdownPipeline.ts";
@@ -38,6 +39,58 @@ it("preserves in-app thread links through the shared Markdown sanitizer", () =>
expect(JSON.stringify(tree)).not.toContain("javascript:");
});
+it("builds the tree rehype-raw builds for markdown without HTML", () => {
+ type Node = {
+ type: string;
+ tagName?: string;
+ value?: string;
+ position?: unknown;
+ data?: unknown;
+ children?: Node[];
+ };
+ // What the round trip changes that renders the same; see `needsHtmlParser`.
+ const comparable = (node: Node): Node => {
+ const { position, children, data, ...rest } = node;
+ const result: Node =
+ node.type === "text" || node.type === "root" ? rest : { ...rest, position, data };
+ if (!children) return result;
+ const merged: Node[] = [];
+ for (const child of children.map(comparable)) {
+ const last = merged.at(-1);
+ if (child.type === "text" && last?.type === "text") last.value += child.value ?? "";
+ else merged.push(child);
+ }
+ // Blank text inside a table moves in front of it; the JSX runtime drops it in tables.
+ const inTable = /^(?:table|thead|tbody|tfoot|tr)$/.test(node.tagName ?? "");
+ result.children = merged.filter(
+ (child, index) =>
+ child.type !== "text" ||
+ child.value?.trim() ||
+ !(inTable || merged[index + 1]?.tagName === "table"),
+ );
+ return result;
+ };
+ const tree = (rehypePlugins: typeof CHAT_MARKDOWN_REHYPE_PLUGINS, markdown: string) => {
+ const processor = unified()
+ .use(remarkParse)
+ .use(CHAT_MARKDOWN_REMARK_PLUGINS)
+ .use(remarkRehype, { allowDangerousHtml: true })
+ .use(rehypePlugins);
+ return comparable(processor.runSync(processor.parse(markdown)) as Node);
+ };
+ const [first, , ...rest] = CHAT_MARKDOWN_REHYPE_PLUGINS;
+ const withRaw = [first!, rehypeRaw, ...rest];
+ for (const markdown of [
+ "- [ ] open\n- [x] done\n\nNote[^1]\n\n[^1]: The note.",
+ "| a | b |\n| :- | -: |\n| `c` |  |\n\n```ts title=x\nconst a = 1;\n```",
+ // The HTML parser moves the footnote's link out of the label's link.
+ "[note[^x]](https://example.com)\n\n[^x]: text",
+ "**a** **b**\r\n> - | a |\r\n> | - |\r\n> | b |\r\n\n-\tx\n\n y",
+ ]) {
+ expect(tree(CHAT_MARKDOWN_REHYPE_PLUGINS, markdown)).toEqual(tree(withRaw, markdown));
+ }
+});
+
it("keeps backslashes that CommonMark would read as escapes in prose Windows paths", () => {
const processor = unified()
.use(remarkParse)
diff --git a/packages/shared/src/markdownPipeline.ts b/packages/shared/src/markdownPipeline.ts
index fe3d73ddac65c..89ebdcf60897c 100644
--- a/packages/shared/src/markdownPipeline.ts
+++ b/packages/shared/src/markdownPipeline.ts
@@ -1,8 +1,9 @@
import type { Paragraph, PhrasingContent, Root, RootContent } from "mdast";
import { remarkKeepWindowsPaths } from "./markdownWindowsPaths.ts";
-import { type PluggableList, unified } from "unified";
+import { type PluggableList, type Processor, unified } from "unified";
import remarkParse from "remark-parse";
import remarkRehype from "remark-rehype";
+import { find, html } from "property-information";
import rehypeRaw from "rehype-raw";
import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
import remarkBreaks from "remark-breaks";
@@ -185,9 +186,79 @@ export const CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS: PluggableList = [
remarkNormalizeLinksAndTagInlineCode,
];
+// Start tags an HTML parser closes an open `` for.
+const CLOSES_PARAGRAPH = new Set(
+ "address article aside blockquote center details dialog dir div dl fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 header hgroup hr li listing main menu nav ol p plaintext pre search section summary table ul xmp dd dt".split(
+ " ",
+ ),
+);
+const HEADING = /^h[1-6]$/;
+
+interface HtmlScope {
+ readonly anchor: boolean;
+ readonly paragraph: boolean;
+ readonly heading: boolean;
+}
+
+/**
+ * Whether the tree needs the HTML parser: raw HTML, or nesting it repairs (a footnote call in a
+ * link label nests ``). Otherwise it only rewrites properties as hast-util-to-parse5 does and
+ * drops `data`, both repeated here, and moves blank text that renders the same.
+ */
+function needsHtmlParser(node: MarkdownImageHastNode, scope: HtmlScope): boolean {
+ if (node.type === "raw") return true;
+ let inner = scope;
+ if (node.type === "element" && node.tagName) {
+ const { tagName } = node;
+ const heading = HEADING.test(tagName);
+ if (
+ (tagName === "a" && scope.anchor) ||
+ (scope.paragraph && CLOSES_PARAGRAPH.has(tagName)) ||
+ (heading && scope.heading)
+ ) {
+ return true;
+ }
+ inner = {
+ anchor: scope.anchor || tagName === "a",
+ paragraph: scope.paragraph || tagName === "p",
+ heading: scope.heading || heading,
+ };
+ const properties = node.properties ?? {};
+ for (const key of Object.keys(properties)) {
+ const value = properties[key];
+ const info = find(html, key);
+ if (
+ value === false ||
+ value === null ||
+ value === undefined ||
+ Number.isNaN(value) ||
+ (!value && info.boolean)
+ ) {
+ delete properties[key];
+ } else if (value === true && !info.boolean && !info.overloadedBoolean) {
+ properties[key] = "";
+ }
+ }
+ delete (node as { data?: unknown }).data;
+ }
+ return (node.children ?? []).some((child) => needsHtmlParser(child, inner));
+}
+
+const TOP_SCOPE: HtmlScope = { anchor: false, paragraph: false, heading: false };
+
+/** rehype-raw reparses the whole tree through an HTML parser, which most trees can skip. */
+function rehypeRawWhenPresent(this: Processor) {
+ const transform = rehypeRaw.call(this) as unknown as (
+ tree: MarkdownImageHastNode,
+ file: unknown,
+ ) => unknown;
+ return (tree: MarkdownImageHastNode, file: unknown) =>
+ needsHtmlParser(tree, TOP_SCOPE) ? transform(tree, file) : undefined;
+}
+
export const CHAT_MARKDOWN_REHYPE_PLUGINS: PluggableList = [
rehypePreserveBareAnchorPlaceholders,
- rehypeRaw,
+ rehypeRawWhenPresent,
rehypePreserveImageSourceMeta,
[rehypeSanitize, CHAT_MARKDOWN_SANITIZE_SCHEMA],
];
@@ -209,6 +280,7 @@ const startsLine = (node: PhrasingContent | undefined) =>
function breakLinesAroundImages(paragraph: Paragraph) {
const children = paragraph.children;
+ if (!children.some(isImageNode)) return;
const ownsLine = (index: number) =>
isImageNode(children[index]) &&
endsLine(children[index - 1]) &&
diff --git a/packages/shared/src/video.test.ts b/packages/shared/src/video.test.ts
index 24ea54b5da835..7f5b29db8155c 100644
--- a/packages/shared/src/video.test.ts
+++ b/packages/shared/src/video.test.ts
@@ -14,4 +14,9 @@ describe("videoMimeType", () => {
"video/webm",
);
});
+
+ it("does not treat a TypeScript file the OS labels as MPEG transport stream as video", () => {
+ expect(videoMimeType({ name: "clamp.ts", mimeType: "video/mp2t" })).toBeNull();
+ expect(videoMimeType({ name: "clamp.ts", mimeType: "video/vnd.dlna.mpeg-tts" })).toBeNull();
+ });
});
diff --git a/packages/shared/src/video.ts b/packages/shared/src/video.ts
index 7979f73e6d537..7e66fe8b8bf1a 100644
--- a/packages/shared/src/video.ts
+++ b/packages/shared/src/video.ts
@@ -17,7 +17,7 @@ export function videoMimeType(attachment: {
readonly mimeType: string;
}): string | null {
const mimeType = attachment.mimeType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
- if (mimeType.startsWith("video/")) return mimeType;
+ if (mimeType.startsWith("video/") && !GENERIC_MIME_TYPES.has(mimeType)) return mimeType;
if (mimeType !== "" && !GENERIC_MIME_TYPES.has(mimeType)) return null;
const dotIndex = attachment.name.lastIndexOf(".");
return dotIndex < 0
diff --git a/packages/source-control-azure-devops/src/shared/definition.ts b/packages/source-control-azure-devops/src/shared/definition.ts
index b43adccedc846..2dd036674747b 100644
--- a/packages/source-control-azure-devops/src/shared/definition.ts
+++ b/packages/source-control-azure-devops/src/shared/definition.ts
@@ -1,15 +1,18 @@
import { SourceControlProviderKind } from "@t3tools/contracts";
import {
+ buildCommitUrl,
changeRequestUrlBelow,
defineSourceControl,
isChangeRequestAuthorityOfProject,
parseChangeRequestPath,
+ parseCommitPath,
remoteWebOrigin,
} from "@t3tools/source-control-core/shared/definition";
import { icon } from "./icon.ts";
// Azure DevOps Server runs on any hostname; its `_git` route identifies it.
const CHANGE_REQUEST_PATH = /^\/((?:[^/]+\/)*_git\/[^/]+)\/pullrequest\/(\d+)(?:\/|$)/u;
+const COMMIT_PATH = /^\/((?:[^/]+\/)*_git\/[^/]+)\/commit\/([0-9a-f]+)\/?$/iu;
const CHECKOUT_COMMAND = /^az\s+repos\s+pr\s+checkout\s+(.+)$/i;
const CHANGE_REQUEST_REFERENCE =
/^https:\/\/(?:dev\.azure\.com\/[^/\s]+\/[^/\s]+|[^/\s]+\.visualstudio\.com\/[^/\s]+)\/_git\/[^/\s]+\/pullrequest\/(\d+)(?:[/?#].*)?$/i;
@@ -88,6 +91,12 @@ export const definition = defineSourceControl({
const [canonicalHost = host, ...path] = (canonicalRepositoryKey(key) ?? key).split("/");
return `${remoteWebOrigin(canonicalHost, remoteUrl)}/${path.join("/")}/pullrequest/${number}`;
},
+ commitUrl: (input) => {
+ const key = `${input.host}/${input.repository}`.toLowerCase();
+ const [host = input.host, ...path] = (canonicalRepositoryKey(key) ?? key).split("/");
+ return buildCommitUrl({ ...input, host, repository: path.join("/") }, "commit");
+ },
+ parseCommitUrl: (url) => parseCommitPath(url, COMMIT_PATH),
// Servers on different ports are different servers, so a port stays in the link.
parseChangeRequestUrl: (url) => {
const link = parseChangeRequestPath(url, CHANGE_REQUEST_PATH);
diff --git a/packages/source-control-bitbucket/src/shared/definition.ts b/packages/source-control-bitbucket/src/shared/definition.ts
index 946098b166d34..a8e786cb0ba6e 100644
--- a/packages/source-control-bitbucket/src/shared/definition.ts
+++ b/packages/source-control-bitbucket/src/shared/definition.ts
@@ -6,11 +6,13 @@ import {
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import {
+ buildCommitUrl,
changeRequestUrlBelow,
defineSourceControl,
isChangeRequestInProjectRepository,
isChangeRequestOnProjectHost,
parseChangeRequestPath,
+ parseCommitPath,
projectChangeRequestHost,
} from "@t3tools/source-control-core/shared/definition";
import { icon } from "./icon.ts";
@@ -19,6 +21,7 @@ const safeShellArgument = /^[A-Za-z0-9._/@+=,-]+$/;
const repositoryName = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/;
const CHANGE_REQUEST_PATH = /^\/([^/]+\/[^/]+)\/pull-requests\/(\d+)(?:\/|$)/u;
+const COMMIT_PATH = /^\/([^/]+\/[^/]+)\/commits\/([0-9a-f]+)\/?$/iu;
const KIND = SourceControlProviderKind.make("bitbucket");
@@ -87,6 +90,9 @@ export const definition = defineSourceControl({
: `https://${host}/${repository}/pull-requests/${number}`,
parseChangeRequestUrl: (url) =>
isBitbucketHost(url.hostname) ? parseChangeRequestPath(url, CHANGE_REQUEST_PATH) : null,
+ commitUrl: (input) => buildCommitUrl(input, "commits"),
+ parseCommitUrl: (url) =>
+ isBitbucketHost(url.hostname) ? parseCommitPath(url, COMMIT_PATH) : null,
changeRequestUrlFromReferenceAutolink: () => null,
// No endpoint reopens a declined pull request, and nothing documented moves one in or out of
// draft, so neither is offered rather than failing when pressed.
diff --git a/packages/source-control-core/src/server/PullRequestProvider.ts b/packages/source-control-core/src/server/PullRequestProvider.ts
index 63dfe8db7a85b..4aa0c06cb8e8e 100644
--- a/packages/source-control-core/src/server/PullRequestProvider.ts
+++ b/packages/source-control-core/src/server/PullRequestProvider.ts
@@ -53,6 +53,11 @@ export class PullRequestProviderError extends Schema.TaggedError {
+ readonly sha: string;
+}
+
export interface ChangeRequestTerminology {
readonly shortLabel: string;
/** Spelled out because the article follows how the label is said: "an MR". */
@@ -238,6 +249,9 @@ export interface SourceControlDefinition {
readonly newRepositoryOwner: (account: string | null) => { readonly owner: string | null } | null;
readonly defaultCloneTransport: "https" | "ssh";
readonly changeRequestUrl: (input: ChangeRequestUrlInput) => string | null;
+ readonly commitUrl?: (input: CommitUrlInput) => string | null;
+ /** `known` is set when the caller already knows this host serves the URL's repository. */
+ readonly parseCommitUrl?: (url: URL, known: boolean) => CommitLink | null;
/** Null when the URL is not one of this host's change requests. */
readonly parseChangeRequestUrl: (url: URL) => ParsedChangeRequestUrl | null;
/**
@@ -290,7 +304,7 @@ export interface SourceControlDefinition {
readonly isChangeRequestReference: (url: string) => boolean;
readonly isChangeRequestInRepository: (
identity: ChangeRequestProjectIdentity,
- link: ChangeRequestLink,
+ link: ChangeRequestLink | CommitLink,
) => boolean;
readonly canReadChangeRequestOnHost: (
identity: ChangeRequestProjectIdentity,
@@ -335,6 +349,42 @@ export type SourceControlHostSettingsSchema = {
readonly fields: Readonly>;
} & Schema.Decoder