tinker-agent 1.5.0 → 1.6.0

package/src/tui/assistant-markdown-section-framer.ts

@@ -0,0 +1,135 @@
+import { lexer, walkTokens, type Token } from "marked";
+
+export type MarkdownSectionFrame = Readonly<{
+  markdown: string;
+  start: number;
+  end: number;
+}>;
+
+export type MarkdownSectionFramerResult = Readonly<{
+  content: string;
+  tail: string;
+  sealedEnd: number;
+  framingStopped: boolean;
+}>;
+
+const ATX_HEADING_LINE = /^ {0,3}#{1,6}(?:[\t ]+|$)/u;
+
+export class MarkdownSectionFramer {
+  private source = "";
+  private scanOffset = 0;
+  private sealedEnd = 0;
+  private framingStopped = false;
+
+  push(content: string): readonly MarkdownSectionFrame[] {
+    if (content === "") {
+      return [];
+    }
+    this.source += content;
+    if (this.framingStopped) {
+      return [];
+    }
+
+    const frames: MarkdownSectionFrame[] = [];
+    while (true) {
+      const newline = this.source.indexOf("\n", this.scanOffset);
+      if (newline === -1) {
+        break;
+      }
+      const lineStart = this.scanOffset;
+      const lineEnd = newline + 1;
+      this.scanOffset = lineEnd;
+      const line = this.source.slice(lineStart, newline).replace(/\r$/u, "");
+      if (!ATX_HEADING_LINE.test(line) || !this.isTopLevelHeading(lineStart, lineEnd)) {
+        continue;
+      }
+
+      const section = this.source.slice(this.sealedEnd, lineStart);
+      if (section.trim() === "") {
+        continue;
+      }
+      if (hasDocumentLevelMarkdownDependency(section)) {
+        this.framingStopped = true;
+        break;
+      }
+
+      frames.push(
+        Object.freeze({
+          markdown: section,
+          start: this.sealedEnd,
+          end: lineStart,
+        }),
+      );
+      this.sealedEnd = lineStart;
+    }
+    return frames;
+  }
+
+  finish(): MarkdownSectionFramerResult {
+    return Object.freeze({
+      content: this.source,
+      tail: this.source.slice(this.sealedEnd),
+      sealedEnd: this.sealedEnd,
+      framingStopped: this.framingStopped,
+    });
+  }
+
+  reset(): void {
+    this.source = "";
+    this.scanOffset = 0;
+    this.sealedEnd = 0;
+    this.framingStopped = false;
+  }
+
+  private isTopLevelHeading(lineStart: number, lineEnd: number): boolean {
+    const markdown = normalizeMarkedSource(this.source.slice(this.sealedEnd, lineEnd));
+    const candidateOffset = normalizeMarkedSource(
+      this.source.slice(this.sealedEnd, lineStart),
+    ).length;
+    let tokenOffset = 0;
+    for (const token of lexer(markdown, { gfm: true })) {
+      if (tokenOffset === candidateOffset && token.type === "heading") {
+        return true;
+      }
+      tokenOffset += token.raw.length;
+    }
+    return false;
+  }
+}
+
+function normalizeMarkedSource(source: string): string {
+  return source.replace(/\r\n|\r/gu, "\n");
+}
+
+function hasDocumentLevelMarkdownDependency(markdown: string): boolean {
+  let found = false;
+  void walkTokens(lexer(markdown, { gfm: true }), (token: Token) => {
+    if (found) {
+      return;
+    }
+    if (token.type === "def") {
+      found = true;
+      return;
+    }
+    if (
+      (token.type === "text" || token.type === "link" || token.type === "image") &&
+      containsReferenceSyntax(token.raw)
+    ) {
+      found = true;
+    }
+  });
+  return found;
+}
+
+function containsReferenceSyntax(source: string): boolean {
+  const bracket = /!?\[(?:\\.|[^\]\\\n])+\](?:[\t ]*\[(?:\\.|[^\]\\\n])*\])?/gu;
+  for (const match of source.matchAll(bracket)) {
+    const value = match[0];
+    const end = (match.index ?? 0) + value.length;
+    const hasSecondLabel = /\][\t ]*\[/u.test(value);
+    if (hasSecondLabel || !/^[\t ]*\(/u.test(source.slice(end))) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/tui/components/assistant-markdown.tsx

@@ -1,38 +1,39 @@
+import { createContext, memo, useContext, type ReactNode } from "react";
+import { MarkdownText, type RenderOptions } from "@assistant-ui/react-ink-markdown";
 import {
-  MarkdownText,
-  type RenderOptions,
-  useShikiHighlighter,
-} from "@assistant-ui/react-ink-markdown";
+  getPreparedShikiHighlighter,
+  type TuiShikiHighlighter,
+} from "../shiki-highlighter";
 
 export type AssistantMarkdownProps = {
   text: string;
 };
 
-const highlightedLanguages = [
-  "typescript",
-  "javascript",
-  "tsx",
-  "jsx",
-  "json",
-  "bash",
-  "shellscript",
-  "python",
-  "markdown",
-  "html",
-  "css",
-  "yaml",
-  "diff",
-];
-
 const tableOptions = {
   tableTruncate: false,
 } satisfies Pick<RenderOptions, "tableTruncate">;
 
-export function AssistantMarkdown(props: AssistantMarkdownProps) {
-  const highlighter = useShikiHighlighter({
-    theme: "github-dark",
-    langs: highlightedLanguages,
-  });
+const HighlighterContext = createContext<TuiShikiHighlighter | undefined>(undefined);
+
+// The runner resolves Shiki initialization before mounting App, so immutable
+// messages can safely move into Ink Static on their first rendered frame.
+export function AssistantMarkdownProvider(props: { children: ReactNode }) {
+  const highlighter = getPreparedShikiHighlighter();
+  return (
+    <HighlighterContext.Provider value={highlighter}>
+      {props.children}
+    </HighlighterContext.Provider>
+  );
+}
+
+// Memoized on `text`: settled assistant messages are immutable, so an
+// unchanged text guarantees an unchanged render and the whole markdown
+// subtree (including the markdansi re-run inside MarkdownText) can be
+// skipped for unrelated frames.
+export const AssistantMarkdown = memo(function AssistantMarkdown(
+  props: AssistantMarkdownProps,
+) {
+  const highlighter = useContext(HighlighterContext);
 
   return (
     <MarkdownText
@@ -44,4 +45,4 @@ export function AssistantMarkdown(props: AssistantMarkdownProps) {
       tableBorder="unicode"
     />
   );
-}
+});

package/src/tui/components/background-tasks.tsx

@@ -2,9 +2,11 @@ import { Box, Text } from "ink";
 import type { ShellTaskSnapshot, ShellTaskStatus } from "../../tools/bash-task";
 
 export type BackgroundTasksProps = {
-  tasks: ShellTaskSnapshot[];
+  tasks: readonly ShellTaskSnapshot[];
 };
 
+const MAX_VISIBLE_TASKS = 5;
+
 export function BackgroundTasks(props: BackgroundTasksProps) {
   if (props.tasks.length === 0) {
     return null;
@@ -13,13 +15,15 @@ export function BackgroundTasks(props: BackgroundTasksProps) {
   const runningCount = props.tasks.filter(
     (task) => task.status === "running" || task.status === "stopping",
   ).length;
+  const visibleTasks = props.tasks.slice(0, MAX_VISIBLE_TASKS);
+  const omittedTaskCount = props.tasks.length - visibleTasks.length;
 
   return (
     <Box flexDirection="column">
       <Text bold>
         Background tasks · {runningCount} running / {props.tasks.length} total
       </Text>
-      {props.tasks.map((task) => (
+      {visibleTasks.map((task) => (
         <Box key={task.taskId} flexDirection="column">
           <Text color={colorForStatus(task.status)}>
             {symbolForStatus(task.status)} {task.status} {taskDescription(task)}
@@ -28,6 +32,7 @@ export function BackgroundTasks(props: BackgroundTasksProps) {
           <Text dimColor>{taskTiming(task)}</Text>
         </Box>
       ))}
+      {omittedTaskCount === 0 ? null : <Text dimColor>+{omittedTaskCount} more</Text>}
     </Box>
   );
 }

package/src/tui/components/bash-confirmation.tsx

@@ -0,0 +1,27 @@
+import { Box, Text, useInput } from "ink";
+
+export type BashConfirmationProps = {
+  command: string;
+  reason: string;
+  onDecision(decision: "allow" | "deny"): void;
+};
+
+export function BashConfirmation(props: BashConfirmationProps) {
+  useInput((input) => {
+    const normalized = input.toLowerCase();
+    if (normalized === "y") {
+      props.onDecision("allow");
+    } else if (normalized === "n") {
+      props.onDecision("deny");
+    }
+  });
+
+  return (
+    <Box flexDirection="column" borderStyle="round" borderColor="yellow" paddingX={1}>
+      <Text color="yellow">Dangerous Bash command</Text>
+      <Text>{props.command}</Text>
+      <Text dimColor>{props.reason}</Text>
+      <Text>y allow / n deny / Esc cancel turn</Text>
+    </Box>
+  );
+}

package/src/tui/components/context-status.tsx

@@ -1,8 +1,12 @@
 import { Box, Text } from "ink";
+import type { BashGuardSnapshot } from "../../agent/runtime-session";
 import type { TuiProjectionState } from "../event-store";
 import { formatContextUsageLine, formatTokenCount } from "../context-format";
 
-export function ContextStatus(props: { state: TuiProjectionState }) {
+export function ContextStatus(props: {
+  state: TuiProjectionState;
+  bashGuard: BashGuardSnapshot;
+}) {
   const usage = props.state.contextUsage;
   const profile = props.state.contextProfile;
   const budget = props.state.contextBudget;
@@ -14,6 +18,12 @@ export function ContextStatus(props: { state: TuiProjectionState }) {
       <Text> model: {props.state.modelName}</Text>
       <Text> workspace: {props.state.workspaceRoot}</Text>
       <Text> </Text>
+      <Text bold>Bash guard</Text>
+      <Text>
+        {" mode: "}
+        {props.bashGuard.mode} (source: {props.bashGuard.source})
+      </Text>
+      <Text> </Text>
       <Text bold>Context</Text>
       {usage === undefined || profile === undefined || budget === undefined ? (
         <Text color="yellow"> measurement unavailable</Text>

package/src/tui/components/file-viewer.tsx

@@ -18,7 +18,7 @@ export type FileViewerProps = {
 export function FileViewer(props: FileViewerProps) {
   const windowSize = useWindowSize();
   const { stdout } = useStdout();
-  const rows = Math.max(4, props.viewportRows ?? windowSize.rows);
+  const rows = Math.max(4, props.viewportRows ?? windowSize.rows - 1);
   const columns = Math.max(20, props.viewportColumns ?? windowSize.columns);
   const bodyRows = Math.max(1, rows - VIEWER_CHROME_ROWS);
   const normalizedLines = useMemo(
@@ -141,7 +141,7 @@ export function FileViewerLoading(props: {
   viewportColumns?: number;
 }) {
   const windowSize = useWindowSize();
-  const rows = Math.max(4, props.viewportRows ?? windowSize.rows);
+  const rows = Math.max(4, props.viewportRows ?? windowSize.rows - 1);
   const columns = Math.max(20, props.viewportColumns ?? windowSize.columns);
 
   useInput((_input, key) => {

package/src/tui/components/footer.tsx

@@ -1,13 +1,13 @@
-import { StatusMessage } from "@inkjs/ui";
-import { Text } from "ink";
+import { Spinner, StatusMessage } from "@inkjs/ui";
 
 export type FooterProps = {
   status: "idle" | "running" | "cancelling" | "cancelled" | "done" | "failed";
   workedForMs?: number;
-  elapsedMs?: number;
+  yolo?: boolean;
 };
 
 export function Footer(props: FooterProps) {
+  const suffix = props.yolo ? " · yolo" : "";
   if (props.status === "done") {
     if (props.workedForMs === undefined) {
       throw new Error("Done footer requires workedForMs");
@@ -16,31 +16,28 @@ export function Footer(props: FooterProps) {
     return (
       <StatusMessage variant="success">
         Worked for {formatDuration(props.workedForMs)}
+        {suffix}
       </StatusMessage>
     );
   }
 
   if (props.status === "failed") {
-    return <StatusMessage variant="error">failed</StatusMessage>;
+    return <StatusMessage variant="error">failed{suffix}</StatusMessage>;
   }
 
   if (props.status === "running") {
-    if (props.elapsedMs === undefined) {
-      return <Text color="yellow">• Running</Text>;
-    }
-
-    return <Text color="yellow">{`• Running ${formatDuration(props.elapsedMs)}`}</Text>;
+    return <Spinner label={`Running${suffix}`} />;
   }
 
   if (props.status === "cancelling") {
-    return <StatusMessage variant="info">cancelling</StatusMessage>;
+    return <StatusMessage variant="info">cancelling{suffix}</StatusMessage>;
   }
 
   if (props.status === "cancelled") {
-    return <StatusMessage variant="info">cancelled</StatusMessage>;
+    return <StatusMessage variant="info">cancelled{suffix}</StatusMessage>;
   }
 
-  return <StatusMessage variant="info">idle</StatusMessage>;
+  return <StatusMessage variant="info">idle{suffix}</StatusMessage>;
 }
 
 function formatDuration(durationMs: number): string {

package/src/tui/components/memory-browser.tsx

@@ -20,7 +20,7 @@ export type MemoryBrowserProps = {
 
 export function MemoryBrowser(props: MemoryBrowserProps) {
   const windowSize = useWindowSize();
-  const rows = Math.max(4, props.viewportRows ?? windowSize.rows);
+  const rows = Math.max(4, props.viewportRows ?? windowSize.rows - 1);
   const columns = Math.max(20, props.viewportColumns ?? windowSize.columns);
   const bodyRows = Math.max(1, rows - BROWSER_CHROME_ROWS);
   const contentRef = useRef<DOMElement>(null);

package/src/tui/components/prompt-input.tsx

@@ -9,7 +9,10 @@ import { ImageNotRecognizedError } from "../../image/image-probe";
 import type { ImportedImageAsset } from "../../image/image-asset-store";
 import type { ImageAssetRef } from "../../image/image-types";
 import { runtimeIdFactory, type RuntimeIdFactory } from "../../ids/runtime-id";
-import { formatContextUsageLine } from "../context-format";
+import {
+  formatContextUsageLine,
+  formatLatestProviderCacheRate,
+} from "../context-format";
 import {
   type FileMentionMatch,
   findFileMention,
@@ -722,6 +725,9 @@ export function PromptInput(props: PromptInputProps) {
   const showFileSuggestions = filePopupActive;
   const showSlashSuggestions = suggestions.length > 0 && !locked;
   const showSuggestions = showFileSuggestions || showSlashSuggestions;
+  const cacheRate = formatLatestProviderCacheRate(
+    props.contextUsage?.lastProviderUsage,
+  );
   return (
     <Box flexDirection="column">
       <Box width="100%" borderStyle="single" borderLeft={false} borderRight={false}>
@@ -745,6 +751,12 @@ export function PromptInput(props: PromptInputProps) {
               </Text>
             </>
           )}
+          {cacheRate === undefined ? null : (
+            <>
+              <Text dimColor> · </Text>
+              <Text dimColor>{cacheRate}</Text>
+            </>
+          )}
         </Box>
       )}
       {showFileSuggestions ? (

package/src/tui/components/resume-session-picker.tsx

@@ -10,6 +10,7 @@ export type ResumeSessionPickerProps = {
   isResuming?: boolean;
   error?: string;
   now?: Date;
+  viewportRows?: number;
   visibleItemCount?: number;
   onCancel: () => void;
   onSelect: (session: SessionSummary) => void;
@@ -29,7 +30,8 @@ export function ResumeSessionPicker(props: ResumeSessionPickerProps) {
 }
 
 function ResumeSessionPickerContent(props: ResumeSessionPickerProps) {
-  const { rows } = useWindowSize();
+  const windowSize = useWindowSize();
+  const rows = props.viewportRows ?? windowSize.rows - 1;
   const visibleItemCount = Math.min(
     props.sessions.length,
     Math.max(

package/src/tui/components/timeline.tsx

@@ -1,32 +1,31 @@
 import { Box, Text } from "ink";
 import { Fragment } from "react";
 import type { TimelineItem } from "../event-store";
+import type { AssistantStreamSectionItem } from "../tui-projection-store";
 import { AssistantMarkdown } from "./assistant-markdown";
 import { BashResultView } from "./bash-result-view";
 import { DiffView } from "./diff-view";
 
 export type TimelineProps = {
-  items: TimelineItem[];
+  items: readonly TimelineItem[];
 };
 
 export function Timeline(props: TimelineProps) {
   return (
     <Box flexDirection="column">
-      <Text bold>Timeline</Text>
-      {props.items.length === 0 ? (
-        <Text color="gray">idle</Text>
-      ) : (
-        props.items.map((item) => renderTimelineItem(item))
-      )}
+      {props.items.map((item) => (
+        <TimelineRow key={item.id} item={item} />
+      ))}
     </Box>
   );
 }
 
-function renderTimelineItem(item: TimelineItem) {
+export function TimelineRow(props: { item: TimelineItem }) {
+  const { item } = props;
   if (item.label !== undefined) {
     if (item.label === "assistant") {
       return (
-        <Fragment key={item.id}>
+        <Fragment>
           <Text color="gray">- {item.label}</Text>
           <AssistantMarkdown text={item.text} />
         </Fragment>
@@ -34,7 +33,7 @@ function renderTimelineItem(item: TimelineItem) {
     }
 
     return (
-      <Fragment key={item.id}>
+      <Fragment>
         <Text color="gray">- {item.label}</Text>
         {item.userPrompt === undefined ? (
           <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
@@ -48,7 +47,7 @@ function renderTimelineItem(item: TimelineItem) {
   }
 
   return (
-    <Fragment key={item.id}>
+    <Fragment>
       <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
       {renderItemBash(item)}
       {renderItemDiff(item)}
@@ -56,6 +55,15 @@ function renderTimelineItem(item: TimelineItem) {
   );
 }
 
+export function AssistantStreamSectionRow(props: { item: AssistantStreamSectionItem }) {
+  return (
+    <Fragment>
+      {props.item.showAssistantLabel ? <Text color="gray">- assistant</Text> : null}
+      <AssistantMarkdown text={props.item.markdown} />
+    </Fragment>
+  );
+}
+
 function renderUserPrompt(prompt: NonNullable<TimelineItem["userPrompt"]>) {
   const chars = [...prompt.text];
   const fragments: React.ReactNode[] = [];

package/src/tui/context-format.ts

@@ -1,4 +1,21 @@
 import type { ContextUsageSnapshot } from "../agent/context-meter";
+import type { ModelUsage } from "../model/model-client";
+
+export function formatLatestProviderCacheRate(
+  usage: ModelUsage | undefined,
+): string | undefined {
+  const hit = usage?.promptCacheHitTokens;
+  const miss = usage?.promptCacheMissTokens;
+  if (hit === undefined || miss === undefined || hit + miss === 0) {
+    return undefined;
+  }
+  // Floor instead of round: an append turn is never a true 100% hit, and
+  // rounding would display 99.5%+ as a misleading "cache 100%". A genuine
+  // full hit (miss === 0, e.g. an identical resent request) still floors to
+  // exactly 100. The min() guards against float rounding when miss > 0.
+  const percent = Math.min(99, Math.floor((hit / (hit + miss)) * 100));
+  return `cache ${miss === 0 ? 100 : percent}%`;
+}
 
 export function formatContextUsageLine(
   usage: Pick<

package/src/tui/event-store.ts

@@ -3,7 +3,7 @@ import {
   bashResultDetail,
   type BashDisplayDetail,
 } from "../events/bash-result-detail";
-import type { AgentEvent } from "../events/types";
+import type { AgentEvent, ModelRequestFailedData } from "../events/types";
 import type { ContextUsageSnapshot } from "../agent/context-meter";
 import type {
   ModelContextBudget,
@@ -162,12 +162,21 @@ export function reduceTuiProjection(
             })
           : updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
               ...item,
-              text: `model iteration ${event.iterationNumber} · retrying`,
+              text: `model iteration ${event.iterationNumber} · retrying (attempt ${event.data.attemptNumber}/${event.data.maxAttempts})`,
               status: "running",
             })),
       );
     case "model.request.failed":
-      return state;
+      if (event.data.retryDisposition !== "scheduled") {
+        return state;
+      }
+      return updateActiveTurn(state, event, policy, (turn) =>
+        updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
+          ...item,
+          text: `model iteration ${requireEventNumber(event.iterationNumber, "model.request.failed iterationNumber")} · ${modelRequestRetryText(event.data)}`,
+          status: "running",
+        })),
+      );
     case "model.request.finished":
       return updateActiveTurn(state, event, policy, (turn) =>
         updateTurnItem(turn, modelRequestRef(event.iterationId), (item) => ({
@@ -214,6 +223,37 @@ export function reduceTuiProjection(
           status: event.data.ok ? "ok" : "failed",
         })),
       );
+    case "tool.confirmation.requested":
+      return updateActiveTurn(state, event, policy, (turn) =>
+        updateTurnItem(
+          turn,
+          toolCallRef(
+            requireEventString(
+              event.toolCallId,
+              "tool.confirmation.requested toolCallId",
+            ),
+          ),
+          (item) => ({
+            ...item,
+            text: `Bash confirmation requested · ${event.data.reason}`,
+            status: "running",
+          }),
+        ),
+      );
+    case "tool.confirmation.resolved":
+      return updateActiveTurn(state, event, policy, (turn) =>
+        appendTurnItem(turn, {
+          id: `confirmation-${event.toolCallId}-${event.eventSequence}`,
+          label: "bash guard",
+          text: `${event.data.decision} · ${event.data.reason}`,
+          status:
+            event.data.decision === "allow"
+              ? "ok"
+              : event.data.decision === "cancelled"
+                ? "cancelled"
+                : "failed",
+        }),
+      );
     case "bash.task.backgrounded":
     case "bash.task.stopping":
     case "bash.task.finished":
@@ -393,6 +433,19 @@ function formatSurfaceComponent(component: string): string {
 
 export const applyAgentEvent = reduceTuiProjection;
 
+export function timelineStreamItems(state: TuiProjectionState): TimelineItem[] {
+  return [
+    ...state.notices,
+    ...state.recentTurns.flatMap((turn) => turn.items),
+    ...(state.activeTurn?.items ?? []),
+  ];
+}
+
+export function firstRunningIndex(items: readonly TimelineItem[]): number {
+  const index = items.findIndex((item) => item.status === "running");
+  return index === -1 ? items.length : index;
+}
+
 export function visibleTimelineItems(state: TuiProjectionState): TimelineItem[] {
   const items = [...state.notices];
 
@@ -666,6 +719,21 @@ export function completedModelRequestText(
   return `model iteration ${iterationNumber} -> assistant response`;
 }
 
+function modelRequestRetryText(data: ModelRequestFailedData): string {
+  const attempt = `attempt ${data.attemptNumber + 1}/${data.maxAttempts}`;
+  if (data.retryDelayMs !== undefined && data.retryDelayMs > 0) {
+    const seconds = Math.max(1, Math.round(data.retryDelayMs / 1000));
+    const reason =
+      data.code === "provider_rate_limited"
+        ? "rate limited"
+        : data.code === "provider_unavailable"
+          ? "provider unavailable"
+          : data.code;
+    return `${reason} · retrying in ${seconds}s (${attempt})`;
+  }
+  return `retrying (${attempt})`;
+}
+
 export function toolCallStartedProjection(input: {
   name: string;
   args: unknown;
@@ -761,6 +829,8 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
         ? base
         : `${base} -> ${raw.bytesWritten} bytes`;
     }
+    case "delete":
+      return `${base} -> deleted`;
     case "web_search":
       return raw.resultCount === undefined
         ? base
@@ -844,6 +914,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "read":
     case "write":
     case "edit":
+    case "delete":
     case "glob":
     case "grep":
     case "task_list":
@@ -877,6 +948,7 @@ function toolRawResultDiff(
             diffTruncated: raw.patchTruncated === true,
           };
     case "read":
+    case "delete":
     case "glob":
     case "grep":
     case "bash":