grok-telegram-bot 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -9,6 +9,52 @@ The latest section is published verbatim as the GitHub Release notes by
 
 ## [Unreleased]
 
+## [2.1.0] - 2026-07-10
+
+The **"show me everything"** release — the bot now streams rich, real-time detail
+for every tool the agent calls, so you can see exactly what's happening: which
+files are being read, edited (with diffs), created, deleted or moved, which
+searches run (pattern + scope + filters), which URLs are fetched, which shell
+commands execute, and which MCP tools are invoked — each with its completion
+status (✅ / ❌ / ⏳).
+
+### Added
+
+- **🔍 Rich tool-call detail for every kind.** Previously most tool calls showed
+  only a bare icon + title line. Now each kind gets its own formatted detail:
+  - **Search** — query/pattern, search path (📂), include/exclude filters
+    (📁/🚫), case-sensitivity flag.
+  - **Read** — file path + line/offset/limit when present.
+  - **Edit** — file path + unified diff block with `+added / -removed` count.
+  - **Write / Create** — file path + content preview with automatic language
+    detection for syntax highlighting (TypeScript, Python, Go, Rust, etc.).
+  - **Delete** — the file being removed.
+  - **Move / Rename** — source path (📄) → destination path (➡️).
+  - **Execute** — the full command in a `bash` code block + working directory.
+  - **Fetch / web_fetch** — URL, HTTP method, headers, and body preview.
+  - **Web search** — query string + result count.
+  - **MCP calls** — server + method + a compact argument preview.
+  - **Generic / unknown** — description or message extracted from raw input.
+- **✅ Status visibility for completed tool calls.** `tool_call_update`
+  notifications carrying `completed` or `failed` status are now shown (previously
+  they were silently deduped away because they shared the `toolCallId` of the
+  initial `tool_call`). You now see the final ✅ or ❌ for each tool action,
+  including diffs that arrive only in the completion update.
+- **🧩 New `tool-call-detail.ts` module** — shared extractors for paths, search
+  queries, URLs, commands, file content, filters, and destination paths, with a
+  `normalizeKind()` that maps common aliases (`bash` → `execute`, `grep` →
+  `search`, `rename` → `move`, etc.) to canonical kinds.
+
+### Changed
+
+- **`formatToolCall` rewritten** from a single switch to per-kind formatter
+  functions, each producing rich RAW markdown. Uses string concatenation instead
+  of template literals to avoid backtick-in-fence escaping issues.
+- **`session-runtime.ts` dedup logic** refined: initial `tool_call` messages are
+  deduped by `toolCallId` (no duplicate); `tool_call_update` with `completed` /
+  `failed` status is shown once (keyed by `toolCallId:done`); `pending` /
+  `in_progress` updates are skipped unless they carry new `content_blocks`.
+
 ## [2.0.0] - 2026-07-09
 
 The **Grok Build** release — the bot now drives the official **xAI Grok Build

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-telegram-bot",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Control the official Grok Build CLI from Telegram over the Agent Client Protocol (ACP). Sign in with your xAI account, switch projects, resume sessions, stream responses with diffs, queue follow-ups, manage multiple sign-ins, and run 24/7 as a cross-platform background service.",
   "type": "module",
   "main": "src/index.ts",

package/src/bot/session-runtime.ts

@@ -1,5 +1,5 @@
 /**
- * SessionRuntime — binds one Telegram chat to one Grok ACP session and drives
+ * SessionRuntime — binds one Telegram chat to one Grok ACP session and drives
  * the prompt/stream lifecycle, typing indicator, follow-up queue, live watch,
  * and per-chat preferences (project, agent, model, reasoning). State persists
  * to the settings store so it survives restarts.
@@ -54,7 +54,7 @@ const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms
 const RESUME_INSTRUCTION =
   "Your previous response was interrupted by a transient service error (the model stream was throttled), " +
   "so your last turn did not finish. Continue from exactly where you stopped and complete the response. " +
-  "Do NOT repeat any file edits, commands, or other tool calls you already completed — their results are " +
+  "Do NOT repeat any file edits, commands, or other tool calls you already completed — their results are " +
   "already in this conversation. If you had already fully answered, just briefly conclude.";
 
 export class SessionRuntime {
@@ -82,7 +82,7 @@ export class SessionRuntime {
   /** Subagent sessionId -> last status key shown this turn (dedupe). */
   private subagentShown = new Map<string, string>();
   private turnStartedAt = 0;
-  /** Count of completed (non-cancelled) turns this session — shown in /usage. */
+  /** Count of completed (non-cancelled) turns this session — shown in /usage. */
   private turnCount = 0;
   /** Telegram message id of the current turn's prompt, so replies thread to it. */
   private turnReplyTo: number | undefined;
@@ -93,7 +93,7 @@ export class SessionRuntime {
   private watcher: TailWatcher | undefined;
   /** True when the active watch is a transient "follow" of this session's own
    *  in-flight turn (started on switch) rather than an explicit /watch of
-   *  another session — follow-watches are auto-stopped when a new turn streams. */
+   *  another session — follow-watches are auto-stopped when a new turn streams. */
   private watchIsFollow = false;
   private rebindPending = false;
   private sessionLive = false;
@@ -159,7 +159,7 @@ export class SessionRuntime {
     return this.lastCompletion;
   }
 
-  /** Latest task-completion % (0–100) parsed this turn, or undefined if none. */
+  /** Latest task-completion % (0–100) parsed this turn, or undefined if none. */
   get taskProgress(): number | undefined {
     return this.progress;
   }
@@ -174,8 +174,8 @@ export class SessionRuntime {
     this.changed();
   }
 
-  /** Searchable hashtag footer for this session (project · session · model ·
-   *  reasoning) — appended to every AI-output surface for this session. */
+  /** Searchable hashtag footer for this session (project В· session В· model В·
+   *  reasoning) — appended to every AI-output surface for this session. */
   get tags(): string {
     return this.hashtags();
   }
@@ -189,7 +189,7 @@ export class SessionRuntime {
     if (value) {
       // A turn was started here and is still in flight, but its streamer was
       // finalized when we went background. Recreate it and let onUpdate feed
-      // the remaining chunks/thoughts/tools just like a normal live turn — we
+      // the remaining chunks/thoughts/tools just like a normal live turn — we
       // own the agent's session/update events, so no tail-watch is needed.
       if (this.busy && !this.streamer) {
         // Any transient follow-watch of this session is now superseded.
@@ -234,7 +234,7 @@ export class SessionRuntime {
     this.stopWatch();
   }
 
-  // ── sessions ───────────────────────────────────────────────────────────────
+  // в”Ђв”Ђ sessions в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async startNewSession(cwd: string, projectName?: string): Promise<void> {
     if (this.busy) await this.cancel();
@@ -314,7 +314,7 @@ export class SessionRuntime {
     return true;
   }
 
-  // ── preferences ──────────────────────────────────────────────────────────
+  // в”Ђв”Ђ preferences в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async setModelPref(modelId: string): Promise<{ ok: boolean; error?: string }> {
     // Persist the choice always; only talk to Grok when a session is live in
@@ -378,7 +378,7 @@ export class SessionRuntime {
     }
   }
 
-  // ── prompting ──────────────────────────────────────────────────────────────
+  // в”Ђв”Ђ prompting в”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђв”Ђ
 
   async submit(input: PromptInput): Promise<"ran" | "queued"> {
     await this.ensureSession();
@@ -425,7 +425,7 @@ export class SessionRuntime {
       // The session genuinely can't be reloaded (its exclusive lock is held,
       // or its log/metadata is gone). Never silently drop the conversation:
       // fork a linked continuation primed with the recent transcript so the
-      // thread survives — including any question the agent had just asked.
+      // thread survives — including any question the agent had just asked.
       // forkFromLostSession() only throws if the agent is fully down, in which
       // case we leave rebindPending set so the next message retries cleanly.
       await this.forkFromLostSession(this.sessionId);
@@ -438,7 +438,7 @@ export class SessionRuntime {
   /** Reload a persisted session, retrying flaky failures with a short backoff.
    *  Returns true once loaded, false after the attempts are exhausted. */
   private async rebindWithRetries(sessionId: string, attempts = 4): Promise<boolean> {
-    const delays = [400, 1200, 3000]; // ≈4.6s total before giving up
+    const delays = [400, 1200, 3000]; // ≈4.6s total before giving up
     for (let i = 0; i < attempts; i++) {
       try {
         await this.acp.loadSession(sessionId, this.cwd);
@@ -518,7 +518,7 @@ export class SessionRuntime {
       if (resumed) final = resumed;
       const streamedOutput = this.streamer?.hasOutput ?? false;
       // On a successful, non-cancelled turn, top the fallback bar up to 100 (a
-      // no-op when the agent reported its own progress — its value is kept).
+      // no-op when the agent reported its own progress — its value is kept).
       if (final.result && !this.cancelled) this.streamer?.completeFallback();
       if (this.streamer) await this.streamer.finalize();
       if (this.foreground) await this.sendTurnImages();
@@ -527,7 +527,7 @@ export class SessionRuntime {
       // the foreground turn, or a background turn when NOTIFY_OTHER_SESSIONS is on.
       const canPing = this.foreground || this.cfg.notifyOtherSessions;
       // A background session about to run a queued follow-up shouldn't ping its
-      // interim "Done" — only the final, queue-empty turn announces completion.
+      // interim "Done" — only the final, queue-empty turn announces completion.
       const hasQueued = this.queue.length > 0;
       const switchKb = this.switchKeyboard();
       if (final.result && !this.cancelled) this.turnCount++;
@@ -594,11 +594,11 @@ export class SessionRuntime {
   }
 
   /**
-   * True when a prompt failure is attributable to an exhausted context window —
+   * True when a prompt failure is attributable to an exhausted context window —
    * either the error message says so, or this session's last-known context
    * usage is at/above the configured fork threshold. Such failures won't clear
    * by retrying the same oversized prompt (throttling on a near-full session
-   * surfaces as a plain "-32603 … throttled"), so the session must be compacted
+   * surfaces as a plain "-32603 … throttled"), so the session must be compacted
    * by forking a fresh, smaller continuation.
    */
   private isContextRelatedFailure(error: Error): boolean {
@@ -663,7 +663,7 @@ export class SessionRuntime {
   /**
    * Auto-rotate-on-give-up. When a turn has failed (retries exhausted, auto-fork
    * didn't recover it) and nothing was streamed, cycle through the OTHER saved
-   * accounts once — switching login + restarting the agent, then retrying the
+   * accounts once — switching login + restarting the agent, then retrying the
    * same prompt on a fresh session for each. The first account that succeeds
    * wins and stays active; if every account fails we return a single combined
    * error listing what each one reported. Bounded to ONE pass (no infinite
@@ -719,14 +719,14 @@ export class SessionRuntime {
       errors.push(`\u2022 ${t.label}: ${last.error?.message ?? "failed"}`);
     }
 
-    // One full cycle done and still failing — stop with a combined report.
+    // One full cycle done and still failing — stop with a combined report.
     const combined = new Error(`Tried ${targets.length + 1} account(s), all failed:\n${errors.join("\n")}`);
     return { error: combined, attempts: last.attempts };
   }
 
   /**
    * Run the prompt, retrying *transient* agent errors (e.g. "high volume of
-   * traffic" / -32603) with an exponential backoff (6s → 12s → 24s → 48s → 60s,
+   * traffic" / -32603) with an exponential backoff (6s в†’ 12s в†’ 24s в†’ 48s в†’ 60s,
    * then give up). The real error is shown to the user on every failed attempt.
    *
    * We only retry while the turn has produced **no streamed output** (so tools
@@ -748,7 +748,7 @@ export class SessionRuntime {
         const error = err as Error;
         const canRecover = !this.cancelled && !(this.streamer?.hasOutput ?? false);
         // A context-exhausted session won't recover by retrying the same
-        // oversized prompt — skip the backoff and let auto-fork compact it now.
+        // oversized prompt — skip the backoff and let auto-fork compact it now.
         const forkInstead = canRecover && this.cfg.autoForkOnError && this.isContextRelatedFailure(error);
         const willRetry =
           attempt <= delays.length &&
@@ -784,8 +784,8 @@ export class SessionRuntime {
    * The pre-stream paths (retry / auto-fork / account-rotate) all bail once any
    * output exists, because re-sending the original prompt would re-execute the
    * tools that already ran (duplicate/destructive side effects). Instead we ask
-   * the SAME session to CONTINUE from where it stopped — its partial reply and
-   * any completed tool results are already in history, so nothing is repeated —
+   * the SAME session to CONTINUE from where it stopped — its partial reply and
+   * any completed tool results are already in history, so nothing is repeated —
    * using the same exponential backoff so a throttle has time to clear. The
    * open streamer keeps appending, so the reply is completed in place.
    *
@@ -800,7 +800,7 @@ export class SessionRuntime {
     if (!(this.streamer?.hasOutput ?? false)) return undefined;
     if (!isTransientError(final.error)) return undefined;
     // A context-full session won't recover by continuing (it'll just throttle
-    // again each attempt) — don't burn the backoff; surface the error so the
+    // again each attempt) — don't burn the backoff; surface the error so the
     // user can fork/compact. Resume targets transient throttles on a session
     // that still has headroom.
     if (this.isContextRelatedFailure(final.error)) return undefined;
@@ -878,7 +878,7 @@ export class SessionRuntime {
     const meta = this.contextInfo();
     const ctx = meta?.contextUsagePercentage;
     const ctxStr = ctx !== undefined ? ` \u00B7 ctx ${ctx.toFixed(0)}%` : "";
-    // Credits consumed this turn — only shown when Grok actually reports it
+    // Credits consumed this turn — only shown when Grok actually reports it
     // (not part of ACP today; degrades to nothing rather than guessing).
     const credits = meta?.credits;
     const creditStr = credits !== undefined ? ` \u00B7 \u{1FA99} ${fmtCredits(credits)}` : "";
@@ -898,7 +898,7 @@ export class SessionRuntime {
     return `\u{1F4E8} From other session ${this.sessionTag()}\n${summary}${shortFiles}\n\n${tags}`;
   }
 
-  /** "[project · 1a2b3c4d]" — identifies which background session a ping is from. */
+  /** "[project · 1a2b3c4d]" — identifies which background session a ping is from. */
   private sessionTag(): string {
     const name = this.projectName || basename(this.cwd) || "session";
     const id = this.sessionId ? ` \u00B7 ${this.sessionId.slice(0, 8)}` : "";
@@ -962,9 +962,29 @@ export class SessionRuntime {
     }
     if (kind === "tool_call" || kind === "tool_call_update") {
       if (!this.cfg.showToolCalls) return;
-      const id = update.toolCallId || `${kind}:${update.title ?? ""}`;
-      if (this.shownToolIds.has(id)) return;
-      this.shownToolIds.add(id);
+      const id = update.toolCallId || "";
+      const status = (update.status || "").toLowerCase();
+
+      if (kind === "tool_call_update") {
+        // Skip "in_progress"/"pending" duplicates of an already-shown initial call.
+        if (status === "pending" || status === "in_progress") {
+          const hasNewContent =
+            Array.isArray(update.content_blocks) && update.content_blocks.length > 0;
+          if (!hasNewContent) return;
+        }
+        // For completed/failed: show once (so the user sees the final status).
+        const doneKey = (id || update.title || "") + ":done";
+        if (status === "completed" || status === "failed") {
+          if (this.shownToolIds.has(doneKey)) return;
+          this.shownToolIds.add(doneKey);
+        }
+      } else {
+        // Initial tool_call: dedupe by id to avoid double-showing.
+        const shownKey = id || `tool_call:${update.title ?? ""}`;
+        if (this.shownToolIds.has(shownKey)) return;
+        this.shownToolIds.add(shownKey);
+      }
+
       const md = formatToolCall(update, {
         showDiffs: this.cfg.showEditDiffs,
         diffMaxLines: this.cfg.diffMaxLines,
@@ -1019,7 +1039,7 @@ export class SessionRuntime {
       .map((e) => {
         const icon = WATCH_ICON[e.role] ?? "\u2022";
         if (e.role === "tool") return `${icon} ${e.tool ? `\`${e.tool}\`` : "tool"}`;
-        const text = e.text.length > WATCH_ENTRY_MAX ? e.text.slice(0, WATCH_ENTRY_MAX) + " …" : e.text;
+        const text = e.text.length > WATCH_ENTRY_MAX ? e.text.slice(0, WATCH_ENTRY_MAX) + " …" : e.text;
         return `${icon} ${text}`;
       })
       .filter(Boolean)

package/src/grok/client.ts

@@ -161,8 +161,12 @@ export class GrokClient extends EventEmitter {
   }
 
   private async connect(): Promise<void> {
-    const args = ["agent", "stdio", "--no-auto-update"];
+    // `--always-approve` is a `grok agent` option (not `grok agent stdio`),
+    // so it must come before the `stdio` subcommand. `--no-auto-update` was
+    // removed in grok 0.2.x and causes exit code 2.
+    const args = ["agent"];
     if (this.opts.trustAllTools) args.push("--always-approve");
+    args.push("stdio");
 
     log.info(`spawning: ${this.opts.grokCliPath} ${args.join(" ")}`);
     const env = { ...process.env };

package/src/render/tool-call-detail.ts

@@ -0,0 +1,170 @@
+/**
+ * tool-call-detail.ts
+ *
+ * Rich detail extractors for specific tool kinds: search queries, file reads,
+ * URLs, writes/creates content previews, move/rename source+dest, delete paths,
+ * web search queries, and MCP argument previews.
+ *
+ * Each function returns a RAW markdown string (code blocks, etc.) appended after
+ * the tool-call icon + title line.
+ */
+import type { SessionUpdate, ToolCallContent } from "../grok/types.js";
+
+/** Max chars to show for search queries, command previews, etc. */
+export const PREVIEW_MAX = 600;
+/** Max chars for file content preview on write/create. */
+export const CONTENT_PREVIEW_MAX = 1000;
+
+/** Normalize a tool-call kind string to a canonical lowercase value. */
+export function normalizeKind(kind: string | undefined): string {
+  const k = (kind || "other").toLowerCase().trim();
+  // Map common variants to canonical kinds.
+  const ALIASES: Record<string, string> = {
+    bash: "execute",
+    shell: "execute",
+    command: "execute",
+    terminal: "execute",
+    grep: "search",
+    glob: "search",
+    find: "search",
+    ripgrep: "search",
+    "web_search": "web_search",
+    "web_fetch": "fetch",
+    url: "fetch",
+    http: "fetch",
+    request: "fetch",
+    rename: "move",
+    copy: "move",
+    mkdir: "create",
+    touch: "create",
+  };
+  return ALIASES[k] ?? k;
+}
+
+/** Extract the primary file path from a tool-call raw input. */
+export function extractPath(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.path) ||
+    strOf(raw.file_path) ||
+    strOf(raw.filename) ||
+    strOf(raw.file) ||
+    strOf(raw.filePath) ||
+    ""
+  );
+}
+
+/** Extract a secondary/destination path (for moves, renames, copies). */
+export function extractDestPath(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.new_path) ||
+    strOf(raw.newPath) ||
+    strOf(raw.destination) ||
+    strOf(raw.dest) ||
+    strOf(raw.to) ||
+    strOf(raw.target_path) ||
+    strOf(raw.targetPath) ||
+    ""
+  );
+}
+
+/** Extract search query / pattern from various raw input shapes. */
+export function extractSearchQuery(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.pattern) ||
+    strOf(raw.query) ||
+    strOf(raw.search) ||
+    strOf(raw.regex) ||
+    strOf(raw.glob) ||
+    strOf(raw.term) ||
+    strOf(raw.q) ||
+    ""
+  );
+}
+
+/** Extract the search path/scope if present. */
+export function extractSearchPath(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.path) ||
+    strOf(raw.directory) ||
+    strOf(raw.dir) ||
+    strOf(raw.scope) ||
+    strOf(raw.cwd) ||
+    strOf(raw.folder) ||
+    ""
+  );
+}
+
+/** Extract a URL from a fetch/web request. */
+export function extractUrl(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.url) ||
+    strOf(raw.uri) ||
+    strOf(raw.link) ||
+    strOf(raw.endpoint) ||
+    ""
+  );
+}
+
+/** Extract command string from an execute/shell call. */
+export function extractCommand(raw: Record<string, unknown>): string {
+  return strOf(raw.command) || strOf(raw.cmd) || strOf(raw.shell_command) || "";
+}
+
+/** Extract file content for write/create operations. */
+export function extractContent(raw: Record<string, unknown>): string {
+  return (
+    strOf(raw.content) ||
+    strOf(raw.file_text) ||
+    strOf(raw.text) ||
+    strOf(raw.data) ||
+    ""
+  );
+}
+
+/** Extract include/exclude filters from a search call. */
+export function extractFilters(raw: Record<string, unknown>): { include?: string; exclude?: string } {
+  const include = strOf(raw.include) || strOf(raw.glob) || strOf(raw.file_pattern) || strOf(raw.type);
+  const exclude = strOf(raw.exclude) || strOf(raw.ignore);
+  const out: { include?: string; exclude?: string } = {};
+  if (include) out.include = include;
+  if (exclude) out.exclude = exclude;
+  return out;
+}
+
+/** Truncate text to max chars with ellipsis. */
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
+/** Collect all content blocks (diffs, text, etc.) from a tool update. */
+export function collectContent(u: SessionUpdate): ToolCallContent[] {
+  const out: ToolCallContent[] = [];
+  if (Array.isArray(u.content_blocks)) out.push(...u.content_blocks);
+  const content = (u as unknown as { content?: unknown }).content;
+  if (Array.isArray(content)) out.push(...(content as ToolCallContent[]));
+  return out;
+}
+
+/** Collect every file path referenced by a tool call. */
+export function gatherPaths(u: SessionUpdate, raw: Record<string, unknown>): string[] {
+  const out: string[] = [];
+  const add = (v: unknown): void => {
+    if (typeof v === "string" && v) out.push(v);
+  };
+  add(raw.path);
+  add(raw.file_path);
+  add(raw.filename);
+  add(raw.file);
+  if (Array.isArray(raw.operations)) {
+    for (const op of raw.operations) {
+      if (op && typeof op === "object") add((op as Record<string, unknown>).path);
+    }
+  }
+  for (const b of collectContent(u)) add(b.path);
+  return out;
+}
+
+function strOf(v: unknown): string {
+  return typeof v === "string" ? v : "";
+}

package/src/render/tool-call.ts

@@ -1,19 +1,41 @@
-/**
+/**
  * Format ACP tool-call updates into clear, RAW markdown blocks so they read
- * distinctly from the agent's prose and thinking. Commands appear in a `bash`
- * block, file edits as a `diff` block.
+ * distinctly from the agent's prose and thinking. Each tool kind gets its own
+ * rich detail: commands in bash blocks, diffs in diff blocks, search queries,
+ * file paths, URLs, content previews, move/rename source+dest, delete paths.
  */
-import type { SessionUpdate, ToolCallContent } from "../grok/types.js";
+import type { SessionUpdate } from "../grok/types.js";
 import { renderUnifiedDiff } from "./diff.js";
+import {
+  normalizeKind,
+  extractPath,
+  extractDestPath,
+  extractSearchQuery,
+  extractSearchPath,
+  extractUrl,
+  extractCommand,
+  extractContent,
+  extractFilters,
+  truncate,
+  collectContent,
+  gatherPaths,
+  PREVIEW_MAX,
+  CONTENT_PREVIEW_MAX,
+} from "./tool-call-detail.js";
 
 const KIND_ICON: Record<string, string> = {
   read: "\u{1F4D6}",
   edit: "\u270F\uFE0F",
+  write: "\u{1F4DD}",
+  create: "\u{1F4DD}",
   execute: "\u{1F4BB}",
   search: "\u{1F50E}",
   delete: "\u{1F5D1}\uFE0F",
   move: "\u{1F4E6}",
+  rename: "\u{1F4E6}",
   fetch: "\u{1F310}",
+  web_search: "\u{1F310}",
+  web_fetch: "\u{1F310}",
   think: "\u{1F4AD}",
   other: "\u{1F527}",
 };
@@ -32,77 +54,275 @@ export interface ToolFormatOptions {
 
 /** Returns a RAW markdown block describing the tool call, or "" to skip. */
 export function formatToolCall(u: SessionUpdate, opts: ToolFormatOptions): string {
-  const kind = (u.kind || "other").toLowerCase();
+  const kind = normalizeKind(u.kind);
   const raw = (u.rawInput || {}) as Record<string, unknown>;
   const status = u.status ? (STATUS_ICON[u.status] ?? "") : "";
-  const tail = status ? ` ${status}` : "";
+  const tail = status ? " " + status : "";
 
-  // Skill load — reading a `.../skills/<name>/SKILL.md`. Don't treat edits/
-  // deletes of a SKILL.md (skill authoring) as a "load".
-  if (kind !== "edit" && kind !== "delete" && kind !== "move") {
+  // Skill load
+  if (kind !== "edit" && kind !== "delete" && kind !== "move" && kind !== "write" && kind !== "create") {
     const skill = detectSkill(u, raw);
-    if (skill) return `\u{1F4DA} **Loaded skill: ${skill}**${tail}`;
+    if (skill) return "\u{1F4DA} **Loaded skill: " + skill + "**" + tail;
   }
 
-  // MCP / extension tool call → "Call MCP <server>: <method>" (or "Call MCP:
-  // <tool>" when the call carries no server name).
+  // MCP / extension tool call
   const mcp = detectMcp(u, raw, kind);
   if (mcp) {
-    const label = mcp.server ? `Call MCP ${mcp.server}: ${mcp.method}` : `Call MCP: ${mcp.method}`;
-    return `\u{1F9E9} **${label}**${tail}`;
+    const label = mcp.server ? "Call MCP " + mcp.server + ": " + mcp.method : "Call MCP: " + mcp.method;
+    let out = "\u{1F9E9} **" + label + "**" + tail;
+    const argPreview = mcpArgPreview(raw);
+    if (argPreview) out += "\n" + fence(argPreview) + "\n";
+    return out;
   }
 
-  const icon = KIND_ICON[kind] ?? KIND_ICON.other;
-  const title = u.title || titleFromRaw(kind, raw);
+  switch (kind) {
+    case "execute":
+      return formatExecute(raw, tail);
+    case "edit":
+      return formatEdit(u, raw, tail, opts);
+    case "write":
+    case "create":
+      return formatWrite(kind, raw, tail);
+    case "read":
+      return formatRead(raw, tail);
+    case "search":
+      return formatSearch(raw, tail);
+    case "delete":
+      return formatDelete(raw, tail);
+    case "move":
+    case "rename":
+      return formatMove(kind, raw, tail);
+    case "fetch":
+    case "web_fetch":
+      return formatFetch(raw, tail);
+    case "web_search":
+      return formatWebSearch(raw, tail);
+    default:
+      return formatGeneric(u, raw, tail, kind);
+  }
+}
 
-  let out = `${icon} **${title}**${tail}`;
+// ---- helpers for code fences (avoid backtick-in-template-literal issues) ----
 
-  if (kind === "execute") {
-    const cmd = strOf(raw.command ?? raw.cmd);
-    if (cmd) out += "\n```bash\n" + cmd + "\n```";
-  }
+/** Wrap text in a fenced code block with optional language. */
+function fence(text: string, lang?: string): string {
+  const marker = "```";
+  return marker + (lang || "") + "\n" + text + "\n" + marker;
+}
+
+// ---- per-kind formatters ----
 
-  if (kind === "edit" && opts.showDiffs) {
+function formatExecute(raw: Record<string, unknown>, tail: string): string {
+  const cmd = extractCommand(raw);
+  const cwd = strOf(raw.cwd);
+  const title = "Run command" + (cwd ? " in " + truncate(cwd, 80) : "");
+  let out = "\u{1F4BB} **" + title + "**" + tail;
+  if (cmd) out += "\n" + fence(truncate(cmd, PREVIEW_MAX), "bash") + "\n";
+  return out;
+}
+
+function formatEdit(u: SessionUpdate, raw: Record<string, unknown>, tail: string, opts: ToolFormatOptions): string {
+  const path = extractPath(raw);
+  const title = "Edit " + (path || "file");
+  let out = "\u270F\uFE0F **" + title + "**" + tail;
+  if (opts.showDiffs) {
     const diff = buildEditDiff(u, raw, opts.diffMaxLines);
     if (diff && diff.block) {
-      const stat = `${diff.added > 0 ? "+" + diff.added : ""}${diff.removed > 0 ? " -" + diff.removed : ""}`.trim();
-      out += `${stat ? `  (${stat})` : ""}\n${diff.block}`;
+      const stat = (diff.added > 0 ? "+" + diff.added : "") + (diff.removed > 0 ? " -" + diff.removed : "");
+      out += (stat.trim() ? "  (" + stat.trim() + ")" : "") + "\n" + diff.block;
     }
   }
+  return out;
+}
+
+function formatWrite(kind: string, raw: Record<string, unknown>, tail: string): string {
+  const path = extractPath(raw);
+  const verb = kind === "create" ? "Create" : "Write";
+  let out = "\u{1F4DD} **" + verb + " " + (path || "file") + "**" + tail;
+  const content = extractContent(raw);
+  if (content) {
+    out += "\n" + fence(truncate(content, CONTENT_PREVIEW_MAX), detectLang(path)) + "\n";
+  }
+  return out;
+}
 
+function formatRead(raw: Record<string, unknown>, tail: string): string {
+  const path = extractPath(raw);
+  const lines = strOf(raw.start_line) || strOf(raw.line);
+  const offset = strOf(raw.offset);
+  const limit = strOf(raw.limit);
+  let title = "Read " + (path || "file");
+  const parts: string[] = [];
+  if (lines) parts.push("line " + lines);
+  if (offset) parts.push("offset " + offset);
+  if (limit) parts.push("limit " + limit);
+  if (parts.length) title += " (" + parts.join(", ") + ")";
+  return "\u{1F4D6} **" + title + "**" + tail;
+}
+
+function formatSearch(raw: Record<string, unknown>, tail: string): string {
+  const query = extractSearchQuery(raw);
+  const path = extractSearchPath(raw);
+  const filters = extractFilters(raw);
+  let title = "Search";
+  if (query) title += ": " + truncate(query, 120);
+  else if (path) title += " " + path;
+  let out = "\u{1F50E} **" + title + "**" + tail;
+  if (path && !query.includes(path)) out += "\n  \u{1F4C2} in: " + truncate(path, 100);
+  if (filters.include) out += "\n  \u{1F4C1} include: " + filters.include;
+  if (filters.exclude) out += "\n  \u{1F6AB} exclude: " + filters.exclude;
+  if (raw.case_sensitive !== undefined)
+    out += "\n  case-sensitive: " + (raw.case_sensitive ? "yes" : "no");
   return out;
 }
 
+function formatDelete(raw: Record<string, unknown>, tail: string): string {
+  const path = extractPath(raw);
+  return "\u{1F5D1}\uFE0F **Delete " + (path || "file") + "**" + tail;
+}
+
+function formatMove(kind: string, raw: Record<string, unknown>, tail: string): string {
+  const src = extractPath(raw);
+  const dst = extractDestPath(raw);
+  const verb = kind === "rename" ? "Rename" : "Move";
+  if (src && dst) {
+    return "\u{1F4E6} **" + verb + "**" + tail + "\n  \u{1F4C4} " + truncate(src, 100) + "\n  \u27A1\uFE0F " + truncate(dst, 100);
+  }
+  return "\u{1F4E6} **" + verb + " " + (src || dst || "file") + "**" + tail;
+}
+
+function formatFetch(raw: Record<string, unknown>, tail: string): string {
+  const url = extractUrl(raw);
+  const method = strOf(raw.method) || strOf(raw.verb) || "GET";
+  let title = "Fetch URL";
+  if (url) title = "Fetch " + truncate(url, 200);
+  let out = "\u{1F310} **" + title + "**" + tail;
+  if (method && method !== "GET") out += "\n  method: " + method;
+  const headers = raw.headers;
+  if (headers && typeof headers === "object") {
+    const hs = JSON.stringify(headers);
+    if (hs !== "{}") out += "\n  headers: " + truncate(hs, 200);
+  }
+  const body = strOf(raw.body) || strOf(raw.data);
+  if (body) out += "\n  body: " + truncate(body, 200);
+  return out;
+}
+
+function formatWebSearch(raw: Record<string, unknown>, tail: string): string {
+  const query = extractSearchQuery(raw) || extractUrl(raw);
+  const count = strOf(raw.count) || strOf(raw.num) || strOf(raw.num_results);
+  let title = "Web search";
+  if (query) title += ": " + truncate(query, 150);
+  let out = "\u{1F310} **" + title + "**" + tail;
+  if (count) out += "\n  results: " + count;
+  return out;
+}
+
+function formatGeneric(u: SessionUpdate, raw: Record<string, unknown>, tail: string, kind: string): string {
+  const icon = KIND_ICON[kind] ?? KIND_ICON.other;
+  const path = extractPath(raw);
+  const title = u.title || (path ? capitalize(kind) + " " + path : capitalize(kind));
+  let out = icon + " **" + title + "**" + tail;
+  const desc = strOf(raw.description) || strOf(raw.message) || strOf(raw.prompt);
+  if (desc) out += "\n  " + truncate(desc, 300);
+  return out;
+}
+
+// ---- diff building ----
+
+function buildEditDiff(u: SessionUpdate, raw: Record<string, unknown>, maxLines: number) {
+  const blocks = collectContent(u);
+  const diffBlock = blocks.find((b) => b.type === "diff");
+  if (diffBlock) {
+    return renderUnifiedDiff({
+      path: strOf(diffBlock.path) || strOf(raw.path) || "file",
+      oldText: typeof diffBlock.oldText === "string" ? diffBlock.oldText : "",
+      newText: typeof diffBlock.newText === "string" ? diffBlock.newText : "",
+      maxLines,
+    });
+  }
+  const oldStr = strOf(raw.old_str) || strOf(raw.oldStr) || strOf(raw.old_string) || strOf(raw.find);
+  const newStr = strOf(raw.new_str) || strOf(raw.newStr) || strOf(raw.new_string) || strOf(raw.replace);
+  if (oldStr || newStr) {
+    return renderUnifiedDiff({ path: strOf(raw.path) || "file", oldText: oldStr, newText: newStr, maxLines });
+  }
+  const content = strOf(raw.file_text) || strOf(raw.content) || strOf(raw.text);
+  if (content) {
+    return renderUnifiedDiff({ path: strOf(raw.path) || "file", oldText: "", newText: content, maxLines });
+  }
+  return undefined;
+}
+
+// ---- language detection ----
+
+function detectLang(path: string): string {
+  const ext = (path.split(".").pop() || "").toLowerCase();
+  const MAP: Record<string, string> = {
+    ts: "typescript", tsx: "tsx", js: "javascript", jsx: "jsx",
+    py: "python", go: "go", rs: "rust", java: "java",
+    c: "c", cpp: "cpp", h: "c", hpp: "cpp",
+    cs: "csharp", rb: "ruby", php: "php", swift: "swift",
+    kt: "kotlin", scala: "scala", sh: "bash", bash: "bash",
+    sql: "sql", html: "html", css: "css", scss: "scss",
+    json: "json", yaml: "yaml", yml: "yaml", xml: "xml",
+    md: "markdown", toml: "toml", ini: "ini", cfg: "ini",
+    vue: "vue", svelte: "svelte", dart: "dart", lua: "lua",
+    r: "r", pl: "perl", ps1: "powershell",
+  };
+  return MAP[ext] || "";
+}
+
+// ---- MCP helpers ----
+
+/** Compact one-line-per-key preview of an MCP call's arguments. */
+function mcpArgPreview(raw: Record<string, unknown>): string {
+  const SKIP = new Set(["tool_name", "toolName", "name", "tool", "type", "_meta"]);
+  const lines: string[] = [];
+  for (const [key, val] of Object.entries(raw)) {
+    if (SKIP.has(key)) continue;
+    let s: string;
+    if (typeof val === "string") s = val;
+    else if (typeof val === "number" || typeof val === "boolean") s = String(val);
+    else {
+      try { s = JSON.stringify(val); } catch { s = String(val); }
+    }
+    if (s.length > 200) s = s.slice(0, 199) + "\u2026";
+    lines.push(key + ": " + s);
+  }
+  return truncate(lines.join("\n"), PREVIEW_MAX);
+}
+
 /** Built-in Grok tools that must never be labelled as MCP calls. */
 const BUILTIN_TOOLS = new Set([
   "read", "write", "shell", "grep", "glob", "web_fetch", "web_search", "fs_read",
   "fs_write", "fs_replace", "fs_search", "execute_bash", "report_issue", "use_aws",
   "todo_list", "introspect", "knowledge", "thinking", "summary", "subagent",
+  "edit", "create", "delete", "move", "rename", "execute", "search", "fetch",
 ]);
 /** Tool kinds that are first-class file/shell operations (never MCP). */
-const FILE_KINDS = new Set(["read", "edit", "execute", "search", "delete", "move"]);
-/** `.../skills/<name>/SKILL.md` — the signature of loading a skill. */
+const FILE_KINDS = new Set([
+  "read", "edit", "execute", "search", "delete", "move", "write", "create",
+  "rename", "fetch", "web_fetch", "web_search",
+]);
+/** `.../skills/<name>/SKILL.md` - the signature of loading a skill. */
 const SKILL_RE = /[\\/]skills[\\/]([^\\/]+)[\\/]SKILL\.md$/i;
-/** Namespaced MCP tool-name shapes → [, server, method]. */
+/** Namespaced MCP tool-name shapes - [, server, method]. */
 const MCP_NS = [
-  /^@([a-z0-9._-]+)[/_]{1,3}(.+)$/i, // @server/method · @server___method
-  /^([a-z0-9.-]+)___(.+)$/i, // server___method
-  /^([a-z0-9.-]+)__(.+)$/i, // server__method
-  /^([a-z0-9.-]+)\/(.+)$/i, // server/method
-  /^([a-z0-9-]+)\.(.+)$/i, // server.method
+  /^@([a-z0-9._-]+)[/_]{1,3}(.+)$/i,
+  /^([a-z0-9.-]+)___(.+)$/i,
+  /^([a-z0-9.-]+)__(.+)$/i,
+  /^([a-z0-9.-]+)\/(.+)$/i,
+  /^([a-z0-9-]+)\.(.+)$/i,
 ];
 
-/** The skill name if this tool call loads a `SKILL.md`, else undefined. */
 function detectSkill(u: SessionUpdate, raw: Record<string, unknown>): string | undefined {
   for (const p of gatherPaths(u, raw)) {
     const m = SKILL_RE.exec(p);
-    if (m) return m[1];
+    if (m) return m[1]!;
   }
   return undefined;
 }
 
-/** The MCP server + method this call targets, if it looks like an MCP/external
- *  tool. Built-in file/shell tools return undefined. */
 function detectMcp(
   u: SessionUpdate,
   raw: Record<string, unknown>,
@@ -114,83 +334,23 @@ function detectMcp(
     const m = re.exec(name);
     if (m) return { server: m[1]!, method: m[2]! };
   }
-  // Bare external tool: not a built-in, and not a file/shell operation.
   if (!BUILTIN_TOOLS.has(name.toLowerCase()) && !FILE_KINDS.has(kind)) {
     return { method: name };
   }
   return undefined;
 }
 
-/** Best-effort tool name from the raw input or a tool-name-like title. */
 function mcpToolName(u: SessionUpdate, raw: Record<string, unknown>): string {
   const explicit = strOf(raw.tool_name) || strOf(raw.toolName) || strOf(raw.name) || strOf(raw.tool);
   if (explicit) return explicit;
   const t = (u.title || "").trim();
-  // Use the title only when it reads like a tool identifier (no spaces, not a
-  // "file:line" read title like "SKILL.md:1").
   return /^[@a-z0-9._/-]+$/i.test(t) && !t.includes(":") ? t : "";
 }
 
-/** Collect every file path referenced by a tool call (incl. nested ops/diffs). */
-function gatherPaths(u: SessionUpdate, raw: Record<string, unknown>): string[] {
-  const out: string[] = [];
-  const add = (v: unknown): void => {
-    if (typeof v === "string" && v) out.push(v);
-  };
-  add(raw.path);
-  add(raw.file_path);
-  add(raw.filename);
-  add(raw.file);
-  if (Array.isArray(raw.operations)) {
-    for (const op of raw.operations) {
-      if (op && typeof op === "object") add((op as Record<string, unknown>).path);
-    }
-  }
-  for (const b of collectContent(u)) add(b.path);
-  return out;
-}
-
-function buildEditDiff(u: SessionUpdate, raw: Record<string, unknown>, maxLines: number) {
-  const blocks = collectContent(u);
-  const diffBlock = blocks.find((b) => b.type === "diff");
-  if (diffBlock) {
-    return renderUnifiedDiff({
-      path: strOf(diffBlock.path) || strOf(raw.path) || "file",
-      oldText: typeof diffBlock.oldText === "string" ? diffBlock.oldText : "",
-      newText: typeof diffBlock.newText === "string" ? diffBlock.newText : "",
-      maxLines,
-    });
-  }
-  const oldStr = strOf(raw.old_str ?? raw.oldStr);
-  const newStr = strOf(raw.new_str ?? raw.newStr);
-  if (oldStr || newStr) {
-    return renderUnifiedDiff({ path: strOf(raw.path) || "file", oldText: oldStr, newText: newStr, maxLines });
-  }
-  const content = strOf(raw.file_text ?? raw.content ?? raw.text);
-  if (content) {
-    return renderUnifiedDiff({ path: strOf(raw.path) || "file", oldText: "", newText: content, maxLines });
-  }
-  return undefined;
-}
-
-function titleFromRaw(kind: string, raw: Record<string, unknown>): string {
-  const path = strOf(raw.path ?? raw.file_path ?? raw.filename);
-  if (path) return `${capitalize(kind)} ${path}`;
-  return capitalize(kind);
-}
-
-function collectContent(u: SessionUpdate): ToolCallContent[] {
-  const out: ToolCallContent[] = [];
-  if (Array.isArray(u.content_blocks)) out.push(...u.content_blocks);
-  const content = (u as unknown as { content?: unknown }).content;
-  if (Array.isArray(content)) out.push(...(content as ToolCallContent[]));
-  return out;
+function capitalize(s: string): string {
+  return s.length ? s[0]!.toUpperCase() + s.slice(1) : s;
 }
 
 function strOf(v: unknown): string {
   return typeof v === "string" ? v : "";
-}
-
-function capitalize(s: string): string {
-  return s.length ? s[0]!.toUpperCase() + s.slice(1) : s;
-}
+}