1package messages
  2
  3import (
  4	"encoding/json"
  5	"fmt"
  6	"strings"
  7	"time"
  8
  9	"github.com/charmbracelet/crush/internal/fsext"
 10	"github.com/charmbracelet/crush/internal/highlight"
 11	"github.com/charmbracelet/crush/internal/llm/agent"
 12	"github.com/charmbracelet/crush/internal/llm/tools"
 13	"github.com/charmbracelet/crush/internal/tui/components/core"
 14	"github.com/charmbracelet/crush/internal/tui/styles"
 15	"github.com/charmbracelet/lipgloss/v2"
 16	"github.com/charmbracelet/lipgloss/v2/tree"
 17	"github.com/charmbracelet/x/ansi"
 18)
 19
 20// responseContextHeight limits the number of lines displayed in tool output
 21const responseContextHeight = 10
 22
 23// renderer defines the interface for tool-specific rendering implementations
 24type renderer interface {
 25	// Render returns the complete (already styled) tool‑call view, not
 26	// including the outer border.
 27	Render(v *toolCallCmp) string
 28}
 29
 30// rendererFactory creates new renderer instances
 31type rendererFactory func() renderer
 32
 33// renderRegistry manages the mapping of tool names to their renderers
 34type renderRegistry map[string]rendererFactory
 35
 36// register adds a new renderer factory to the registry
 37func (rr renderRegistry) register(name string, f rendererFactory) { rr[name] = f }
 38
 39// lookup retrieves a renderer for the given tool name, falling back to generic renderer
 40func (rr renderRegistry) lookup(name string) renderer {
 41	if f, ok := rr[name]; ok {
 42		return f()
 43	}
 44	return genericRenderer{} // sensible fallback
 45}
 46
 47// registry holds all registered tool renderers
 48var registry = renderRegistry{}
 49
 50// baseRenderer provides common functionality for all tool renderers
 51type baseRenderer struct{}
 52
 53// paramBuilder helps construct parameter lists for tool headers
 54type paramBuilder struct {
 55	args []string
 56}
 57
 58// newParamBuilder creates a new parameter builder
 59func newParamBuilder() *paramBuilder {
 60	return &paramBuilder{args: make([]string, 0)}
 61}
 62
 63// addMain adds the main parameter (first argument)
 64func (pb *paramBuilder) addMain(value string) *paramBuilder {
 65	if value != "" {
 66		pb.args = append(pb.args, value)
 67	}
 68	return pb
 69}
 70
 71// addKeyValue adds a key-value pair parameter
 72func (pb *paramBuilder) addKeyValue(key, value string) *paramBuilder {
 73	if value != "" {
 74		pb.args = append(pb.args, key, value)
 75	}
 76	return pb
 77}
 78
 79// addFlag adds a boolean flag parameter
 80func (pb *paramBuilder) addFlag(key string, value bool) *paramBuilder {
 81	if value {
 82		pb.args = append(pb.args, key, "true")
 83	}
 84	return pb
 85}
 86
 87// build returns the final parameter list
 88func (pb *paramBuilder) build() []string {
 89	return pb.args
 90}
 91
 92// renderWithParams provides a common rendering pattern for tools with parameters
 93func (br baseRenderer) renderWithParams(v *toolCallCmp, toolName string, args []string, contentRenderer func() string) string {
 94	width := v.textWidth()
 95	if v.isNested {
 96		width -= 4 // Adjust for nested tool call indentation
 97	}
 98	header := br.makeHeader(v, toolName, width, args...)
 99	if v.isNested {
100		return v.style().Render(header)
101	}
102	if res, done := earlyState(header, v); done {
103		return res
104	}
105	body := contentRenderer()
106	return joinHeaderBody(header, body)
107}
108
109// unmarshalParams safely unmarshal JSON parameters
110func (br baseRenderer) unmarshalParams(input string, target any) error {
111	return json.Unmarshal([]byte(input), target)
112}
113
114// makeHeader builds the tool call header with status icon and parameters for a nested tool call.
115func (br baseRenderer) makeNestedHeader(v *toolCallCmp, tool string, width int, params ...string) string {
116	t := styles.CurrentTheme()
117	tool = t.S().Base.Foreground(t.FgHalfMuted).Render(tool) + " "
118	return tool + renderParamList(true, width-lipgloss.Width(tool), params...)
119}
120
121// makeHeader builds "<Tool>: param (key=value)" and truncates as needed.
122func (br baseRenderer) makeHeader(v *toolCallCmp, tool string, width int, params ...string) string {
123	if v.isNested {
124		return br.makeNestedHeader(v, tool, width, params...)
125	}
126	t := styles.CurrentTheme()
127	icon := t.S().Base.Foreground(t.GreenDark).Render(styles.ToolPending)
128	if v.result.ToolCallID != "" {
129		if v.result.IsError {
130			icon = t.S().Base.Foreground(t.RedDark).Render(styles.ToolError)
131		} else {
132			icon = t.S().Base.Foreground(t.Green).Render(styles.ToolSuccess)
133		}
134	} else if v.cancelled {
135		icon = t.S().Muted.Render(styles.ToolPending)
136	}
137	tool = t.S().Base.Foreground(t.Blue).Render(tool)
138	prefix := fmt.Sprintf("%s %s ", icon, tool)
139	return prefix + renderParamList(false, width-lipgloss.Width(prefix), params...)
140}
141
142// renderError provides consistent error rendering
143func (br baseRenderer) renderError(v *toolCallCmp, message string) string {
144	t := styles.CurrentTheme()
145	header := br.makeHeader(v, prettifyToolName(v.call.Name), v.textWidth(), "")
146	message = t.S().Error.Render(v.fit(message, v.textWidth()-2)) // -2 for padding
147	return joinHeaderBody(header, message)
148}
149
150// Register tool renderers
151func init() {
152	registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
153	registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
154	registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
155	registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
156	registry.register(tools.FetchToolName, func() renderer { return fetchRenderer{} })
157	registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
158	registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
159	registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
160	registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
161	registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
162	registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
163}
164
165// -----------------------------------------------------------------------------
166//  Generic renderer
167// -----------------------------------------------------------------------------
168
169// genericRenderer handles unknown tool types with basic parameter display
170type genericRenderer struct {
171	baseRenderer
172}
173
174// Render displays the tool call with its raw input and plain content output
175func (gr genericRenderer) Render(v *toolCallCmp) string {
176	return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
177		return renderPlainContent(v, v.result.Content)
178	})
179}
180
181// -----------------------------------------------------------------------------
182//  Bash renderer
183// -----------------------------------------------------------------------------
184
185// bashRenderer handles bash command execution display
186type bashRenderer struct {
187	baseRenderer
188}
189
190// Render displays the bash command with sanitized newlines and plain output
191func (br bashRenderer) Render(v *toolCallCmp) string {
192	var params tools.BashParams
193	if err := br.unmarshalParams(v.call.Input, &params); err != nil {
194		return br.renderError(v, "Invalid bash parameters")
195	}
196
197	cmd := strings.ReplaceAll(params.Command, "\n", " ")
198	args := newParamBuilder().addMain(cmd).build()
199
200	return br.renderWithParams(v, "Bash", args, func() string {
201		return renderPlainContent(v, v.result.Content)
202	})
203}
204
205// -----------------------------------------------------------------------------
206//  View renderer
207// -----------------------------------------------------------------------------
208
209// viewRenderer handles file viewing with syntax highlighting and line numbers
210type viewRenderer struct {
211	baseRenderer
212}
213
214// Render displays file content with optional limit and offset parameters
215func (vr viewRenderer) Render(v *toolCallCmp) string {
216	var params tools.ViewParams
217	if err := vr.unmarshalParams(v.call.Input, &params); err != nil {
218		return vr.renderError(v, "Invalid view parameters")
219	}
220
221	file := fsext.PrettyPath(params.FilePath)
222	args := newParamBuilder().
223		addMain(file).
224		addKeyValue("limit", formatNonZero(params.Limit)).
225		addKeyValue("offset", formatNonZero(params.Offset)).
226		build()
227
228	return vr.renderWithParams(v, "View", args, func() string {
229		var meta tools.ViewResponseMetadata
230		if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
231			return renderPlainContent(v, v.result.Content)
232		}
233		return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
234	})
235}
236
237// formatNonZero returns string representation of non-zero integers, empty string for zero
238func formatNonZero(value int) string {
239	if value == 0 {
240		return ""
241	}
242	return fmt.Sprintf("%d", value)
243}
244
245// -----------------------------------------------------------------------------
246//  Edit renderer
247// -----------------------------------------------------------------------------
248
249// editRenderer handles file editing with diff visualization
250type editRenderer struct {
251	baseRenderer
252}
253
254// Render displays the edited file with a formatted diff of changes
255func (er editRenderer) Render(v *toolCallCmp) string {
256	var params tools.EditParams
257	if err := er.unmarshalParams(v.call.Input, &params); err != nil {
258		return er.renderError(v, "Invalid edit parameters")
259	}
260
261	file := fsext.PrettyPath(params.FilePath)
262	args := newParamBuilder().addMain(file).build()
263
264	return er.renderWithParams(v, "Edit", args, func() string {
265		var meta tools.EditResponseMetadata
266		if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
267			return renderPlainContent(v, v.result.Content)
268		}
269
270		formatter := core.DiffFormatter().
271			Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
272			After(fsext.PrettyPath(params.FilePath), meta.NewContent).
273			Width(v.textWidth() - 2) // -2 for padding
274		if v.textWidth() > 120 {
275			formatter = formatter.Split()
276		}
277		return formatter.String()
278	})
279}
280
281// -----------------------------------------------------------------------------
282//  Write renderer
283// -----------------------------------------------------------------------------
284
285// writeRenderer handles file writing with syntax-highlighted content preview
286type writeRenderer struct {
287	baseRenderer
288}
289
290// Render displays the file being written with syntax highlighting
291func (wr writeRenderer) Render(v *toolCallCmp) string {
292	var params tools.WriteParams
293	if err := wr.unmarshalParams(v.call.Input, &params); err != nil {
294		return wr.renderError(v, "Invalid write parameters")
295	}
296
297	file := fsext.PrettyPath(params.FilePath)
298	args := newParamBuilder().addMain(file).build()
299
300	return wr.renderWithParams(v, "Write", args, func() string {
301		return renderCodeContent(v, file, params.Content, 0)
302	})
303}
304
305// -----------------------------------------------------------------------------
306//  Fetch renderer
307// -----------------------------------------------------------------------------
308
309// fetchRenderer handles URL fetching with format-specific content display
310type fetchRenderer struct {
311	baseRenderer
312}
313
314// Render displays the fetched URL with format and timeout parameters
315func (fr fetchRenderer) Render(v *toolCallCmp) string {
316	var params tools.FetchParams
317	if err := fr.unmarshalParams(v.call.Input, &params); err != nil {
318		return fr.renderError(v, "Invalid fetch parameters")
319	}
320
321	args := newParamBuilder().
322		addMain(params.URL).
323		addKeyValue("format", params.Format).
324		addKeyValue("timeout", formatTimeout(params.Timeout)).
325		build()
326
327	return fr.renderWithParams(v, "Fetch", args, func() string {
328		file := fr.getFileExtension(params.Format)
329		return renderCodeContent(v, file, v.result.Content, 0)
330	})
331}
332
333// getFileExtension returns appropriate file extension for syntax highlighting
334func (fr fetchRenderer) getFileExtension(format string) string {
335	switch format {
336	case "text":
337		return "fetch.txt"
338	case "html":
339		return "fetch.html"
340	default:
341		return "fetch.md"
342	}
343}
344
345// formatTimeout converts timeout seconds to duration string
346func formatTimeout(timeout int) string {
347	if timeout == 0 {
348		return ""
349	}
350	return (time.Duration(timeout) * time.Second).String()
351}
352
353// -----------------------------------------------------------------------------
354//  Glob renderer
355// -----------------------------------------------------------------------------
356
357// globRenderer handles file pattern matching with path filtering
358type globRenderer struct {
359	baseRenderer
360}
361
362// Render displays the glob pattern with optional path parameter
363func (gr globRenderer) Render(v *toolCallCmp) string {
364	var params tools.GlobParams
365	if err := gr.unmarshalParams(v.call.Input, &params); err != nil {
366		return gr.renderError(v, "Invalid glob parameters")
367	}
368
369	args := newParamBuilder().
370		addMain(params.Pattern).
371		addKeyValue("path", params.Path).
372		build()
373
374	return gr.renderWithParams(v, "Glob", args, func() string {
375		return renderPlainContent(v, v.result.Content)
376	})
377}
378
379// -----------------------------------------------------------------------------
380//  Grep renderer
381// -----------------------------------------------------------------------------
382
383// grepRenderer handles content searching with pattern matching options
384type grepRenderer struct {
385	baseRenderer
386}
387
388// Render displays the search pattern with path, include, and literal text options
389func (gr grepRenderer) Render(v *toolCallCmp) string {
390	var params tools.GrepParams
391	if err := gr.unmarshalParams(v.call.Input, &params); err != nil {
392		return gr.renderError(v, "Invalid grep parameters")
393	}
394
395	args := newParamBuilder().
396		addMain(params.Pattern).
397		addKeyValue("path", params.Path).
398		addKeyValue("include", params.Include).
399		addFlag("literal", params.LiteralText).
400		build()
401
402	return gr.renderWithParams(v, "Grep", args, func() string {
403		return renderPlainContent(v, v.result.Content)
404	})
405}
406
407// -----------------------------------------------------------------------------
408//  LS renderer
409// -----------------------------------------------------------------------------
410
411// lsRenderer handles directory listing with default path handling
412type lsRenderer struct {
413	baseRenderer
414}
415
416// Render displays the directory path, defaulting to current directory
417func (lr lsRenderer) Render(v *toolCallCmp) string {
418	var params tools.LSParams
419	if err := lr.unmarshalParams(v.call.Input, &params); err != nil {
420		return lr.renderError(v, "Invalid ls parameters")
421	}
422
423	path := params.Path
424	if path == "" {
425		path = "."
426	}
427	path = fsext.PrettyPath(path)
428
429	args := newParamBuilder().addMain(path).build()
430
431	return lr.renderWithParams(v, "List", args, func() string {
432		return renderPlainContent(v, v.result.Content)
433	})
434}
435
436// -----------------------------------------------------------------------------
437//  Sourcegraph renderer
438// -----------------------------------------------------------------------------
439
440// sourcegraphRenderer handles code search with count and context options
441type sourcegraphRenderer struct {
442	baseRenderer
443}
444
445// Render displays the search query with optional count and context window parameters
446func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
447	var params tools.SourcegraphParams
448	if err := sr.unmarshalParams(v.call.Input, &params); err != nil {
449		return sr.renderError(v, "Invalid sourcegraph parameters")
450	}
451
452	args := newParamBuilder().
453		addMain(params.Query).
454		addKeyValue("count", formatNonZero(params.Count)).
455		addKeyValue("context", formatNonZero(params.ContextWindow)).
456		build()
457
458	return sr.renderWithParams(v, "Sourcegraph", args, func() string {
459		return renderPlainContent(v, v.result.Content)
460	})
461}
462
463// -----------------------------------------------------------------------------
464//  Diagnostics renderer
465// -----------------------------------------------------------------------------
466
467// diagnosticsRenderer handles project-wide diagnostic information
468type diagnosticsRenderer struct {
469	baseRenderer
470}
471
472// Render displays project diagnostics with plain content formatting
473func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
474	args := newParamBuilder().addMain("project").build()
475
476	return dr.renderWithParams(v, "Diagnostics", args, func() string {
477		return renderPlainContent(v, v.result.Content)
478	})
479}
480
481// -----------------------------------------------------------------------------
482//  Task renderer
483// -----------------------------------------------------------------------------
484
485// agentRenderer handles project-wide diagnostic information
486type agentRenderer struct {
487	baseRenderer
488}
489
490func RoundedEnumerator(children tree.Children, index int) string {
491	if children.Length()-1 == index {
492		return " ╰──"
493	}
494	return " ├──"
495}
496
497// Render displays agent task parameters and result content
498func (tr agentRenderer) Render(v *toolCallCmp) string {
499	t := styles.CurrentTheme()
500	var params agent.AgentParams
501	if err := tr.unmarshalParams(v.call.Input, &params); err != nil {
502		return tr.renderError(v, "Invalid task parameters")
503	}
504	prompt := params.Prompt
505	prompt = strings.ReplaceAll(prompt, "\n", " ")
506
507	header := tr.makeHeader(v, "Agent", v.textWidth())
508	taskTag := t.S().Base.Padding(0, 1).MarginLeft(1).Background(t.BlueLight).Foreground(t.White).Render("Task")
509	remainingWidth := v.textWidth() - lipgloss.Width(header) - lipgloss.Width(taskTag) - 2 // -2 for padding
510	prompt = t.S().Muted.Width(remainingWidth).Render(prompt)
511	header = lipgloss.JoinVertical(
512		lipgloss.Left,
513		header,
514		"",
515		lipgloss.JoinHorizontal(
516			lipgloss.Left,
517			taskTag,
518			" ",
519			prompt,
520		),
521	)
522	childTools := tree.Root(header)
523
524	for _, call := range v.nestedToolCalls {
525		childTools.Child(call.View())
526	}
527	parts := []string{
528		childTools.Enumerator(RoundedEnumerator).String(),
529	}
530	if v.result.ToolCallID == "" {
531		v.spinning = true
532		parts = append(parts, v.anim.View().String())
533	} else {
534		v.spinning = false
535	}
536
537	header = lipgloss.JoinVertical(
538		lipgloss.Left,
539		parts...,
540	)
541
542	if v.result.ToolCallID == "" {
543		return header
544	}
545
546	body := renderPlainContent(v, v.result.Content)
547	return joinHeaderBody(header, body)
548}
549
550// renderParamList renders params, params[0] (params[1]=params[2] ....)
551func renderParamList(nested bool, paramsWidth int, params ...string) string {
552	t := styles.CurrentTheme()
553	if len(params) == 0 {
554		return ""
555	}
556	mainParam := params[0]
557	if len(mainParam) > paramsWidth {
558		mainParam = mainParam[:paramsWidth-3] + "..."
559	}
560
561	if len(params) == 1 {
562		if nested {
563			return t.S().Muted.Render(mainParam)
564		}
565		return t.S().Subtle.Render(mainParam)
566	}
567	otherParams := params[1:]
568	// create pairs of key/value
569	// if odd number of params, the last one is a key without value
570	if len(otherParams)%2 != 0 {
571		otherParams = append(otherParams, "")
572	}
573	parts := make([]string, 0, len(otherParams)/2)
574	for i := 0; i < len(otherParams); i += 2 {
575		key := otherParams[i]
576		value := otherParams[i+1]
577		if value == "" {
578			continue
579		}
580		parts = append(parts, fmt.Sprintf("%s=%s", key, value))
581	}
582
583	partsRendered := strings.Join(parts, ", ")
584	remainingWidth := paramsWidth - lipgloss.Width(partsRendered) - 3 // count for " ()"
585	if remainingWidth < 30 {
586		if nested {
587			return t.S().Muted.Render(mainParam)
588		}
589		// No space for the params, just show the main
590		return t.S().Subtle.Render(mainParam)
591	}
592
593	if len(parts) > 0 {
594		mainParam = fmt.Sprintf("%s (%s)", mainParam, strings.Join(parts, ", "))
595	}
596
597	if nested {
598		return t.S().Muted.Render(ansi.Truncate(mainParam, paramsWidth, "..."))
599	}
600	return t.S().Subtle.Render(ansi.Truncate(mainParam, paramsWidth, "..."))
601}
602
603// earlyState returns immediately‑rendered error/cancelled/ongoing states.
604func earlyState(header string, v *toolCallCmp) (string, bool) {
605	t := styles.CurrentTheme()
606	message := ""
607	switch {
608	case v.result.IsError:
609		message = v.renderToolError()
610	case v.cancelled:
611		message = "Cancelled"
612	case v.result.ToolCallID == "":
613		message = "Waiting for tool to start..."
614	default:
615		return "", false
616	}
617
618	message = t.S().Base.PaddingLeft(2).Render(message)
619	return lipgloss.JoinVertical(lipgloss.Left, header, message), true
620}
621
622func joinHeaderBody(header, body string) string {
623	t := styles.CurrentTheme()
624	body = t.S().Base.PaddingLeft(2).Render(body)
625	return lipgloss.JoinVertical(lipgloss.Left, header, "", body, "")
626}
627
628func renderPlainContent(v *toolCallCmp, content string) string {
629	t := styles.CurrentTheme()
630	content = strings.TrimSpace(content)
631	lines := strings.Split(content, "\n")
632
633	width := v.textWidth() - 2 // -2 for left padding
634	var out []string
635	for i, ln := range lines {
636		if i >= responseContextHeight {
637			break
638		}
639		ln = " " + ln // left padding
640		if len(ln) > width {
641			ln = v.fit(ln, width)
642		}
643		out = append(out, t.S().Muted.
644			Width(width).
645			Background(t.BgBaseLighter).
646			Render(ln))
647	}
648
649	if len(lines) > responseContextHeight {
650		out = append(out, t.S().Muted.
651			Background(t.BgBaseLighter).
652			Width(width).
653			Render(fmt.Sprintf("... (%d lines)", len(lines)-responseContextHeight)))
654	}
655	return strings.Join(out, "\n")
656}
657
658func pad(v any, width int) string {
659	s := fmt.Sprintf("%v", v)
660	w := ansi.StringWidth(s)
661	if w >= width {
662		return s
663	}
664	return strings.Repeat(" ", width-w) + s
665}
666
667func renderCodeContent(v *toolCallCmp, path, content string, offset int) string {
668	t := styles.CurrentTheme()
669	truncated := truncateHeight(content, responseContextHeight)
670
671	highlighted, _ := highlight.SyntaxHighlight(truncated, path, t.BgBase)
672	lines := strings.Split(highlighted, "\n")
673
674	if len(strings.Split(content, "\n")) > responseContextHeight {
675		lines = append(lines, t.S().Muted.
676			Background(t.BgBase).
677			Render(fmt.Sprintf(" …(%d lines)", len(strings.Split(content, "\n"))-responseContextHeight)))
678	}
679
680	maxLineNumber := len(lines) + offset
681	padding := lipgloss.Width(fmt.Sprintf("%d", maxLineNumber))
682	for i, ln := range lines {
683		num := t.S().Base.
684			Foreground(t.FgMuted).
685			Background(t.BgBase).
686			PaddingRight(1).
687			PaddingLeft(1).
688			Render(pad(i+1+offset, padding))
689		w := v.textWidth() - 10 - lipgloss.Width(num) // -4 for left padding
690		lines[i] = lipgloss.JoinHorizontal(lipgloss.Left,
691			num,
692			t.S().Base.
693				PaddingLeft(1).
694				Render(v.fit(ln, w-1)))
695	}
696	return lipgloss.JoinVertical(lipgloss.Left, lines...)
697}
698
699func (v *toolCallCmp) renderToolError() string {
700	t := styles.CurrentTheme()
701	err := strings.ReplaceAll(v.result.Content, "\n", " ")
702	err = fmt.Sprintf("Error: %s", err)
703	return t.S().Base.Foreground(t.Error).Render(v.fit(err, v.textWidth()-2))
704}
705
706func truncateHeight(s string, h int) string {
707	lines := strings.Split(s, "\n")
708	if len(lines) > h {
709		return strings.Join(lines[:h], "\n")
710	}
711	return s
712}
713
714func prettifyToolName(name string) string {
715	switch name {
716	case agent.AgentToolName:
717		return "Agent"
718	case tools.BashToolName:
719		return "Bash"
720	case tools.EditToolName:
721		return "Edit"
722	case tools.FetchToolName:
723		return "Fetch"
724	case tools.GlobToolName:
725		return "Glob"
726	case tools.GrepToolName:
727		return "Grep"
728	case tools.LSToolName:
729		return "List"
730	case tools.SourcegraphToolName:
731		return "Sourcegraph"
732	case tools.ViewToolName:
733		return "View"
734	case tools.WriteToolName:
735		return "Write"
736	default:
737		return name
738	}
739}