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 ¶mBuilder{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 errorTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
147 message = t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(message, v.textWidth()-3-lipgloss.Width(errorTag))) // -2 for padding and space
148 return joinHeaderBody(header, errorTag+" "+message)
149}
150
151// Register tool renderers
152func init() {
153 registry.register(tools.BashToolName, func() renderer { return bashRenderer{} })
154 registry.register(tools.ViewToolName, func() renderer { return viewRenderer{} })
155 registry.register(tools.EditToolName, func() renderer { return editRenderer{} })
156 registry.register(tools.WriteToolName, func() renderer { return writeRenderer{} })
157 registry.register(tools.FetchToolName, func() renderer { return fetchRenderer{} })
158 registry.register(tools.GlobToolName, func() renderer { return globRenderer{} })
159 registry.register(tools.GrepToolName, func() renderer { return grepRenderer{} })
160 registry.register(tools.LSToolName, func() renderer { return lsRenderer{} })
161 registry.register(tools.SourcegraphToolName, func() renderer { return sourcegraphRenderer{} })
162 registry.register(tools.DiagnosticsToolName, func() renderer { return diagnosticsRenderer{} })
163 registry.register(agent.AgentToolName, func() renderer { return agentRenderer{} })
164}
165
166// -----------------------------------------------------------------------------
167// Generic renderer
168// -----------------------------------------------------------------------------
169
170// genericRenderer handles unknown tool types with basic parameter display
171type genericRenderer struct {
172 baseRenderer
173}
174
175// Render displays the tool call with its raw input and plain content output
176func (gr genericRenderer) Render(v *toolCallCmp) string {
177 return gr.renderWithParams(v, prettifyToolName(v.call.Name), []string{v.call.Input}, func() string {
178 return renderPlainContent(v, v.result.Content)
179 })
180}
181
182// -----------------------------------------------------------------------------
183// Bash renderer
184// -----------------------------------------------------------------------------
185
186// bashRenderer handles bash command execution display
187type bashRenderer struct {
188 baseRenderer
189}
190
191// Render displays the bash command with sanitized newlines and plain output
192func (br bashRenderer) Render(v *toolCallCmp) string {
193 var params tools.BashParams
194 if err := br.unmarshalParams(v.call.Input, ¶ms); err != nil {
195 return br.renderError(v, "Invalid bash parameters")
196 }
197
198 cmd := strings.ReplaceAll(params.Command, "\n", " ")
199 args := newParamBuilder().addMain(cmd).build()
200
201 return br.renderWithParams(v, "Bash", args, func() string {
202 if v.result.Content == tools.BashNoOutput {
203 return ""
204 }
205 return renderPlainContent(v, v.result.Content)
206 })
207}
208
209// -----------------------------------------------------------------------------
210// View renderer
211// -----------------------------------------------------------------------------
212
213// viewRenderer handles file viewing with syntax highlighting and line numbers
214type viewRenderer struct {
215 baseRenderer
216}
217
218// Render displays file content with optional limit and offset parameters
219func (vr viewRenderer) Render(v *toolCallCmp) string {
220 var params tools.ViewParams
221 if err := vr.unmarshalParams(v.call.Input, ¶ms); err != nil {
222 return vr.renderError(v, "Invalid view parameters")
223 }
224
225 file := fsext.PrettyPath(params.FilePath)
226 args := newParamBuilder().
227 addMain(file).
228 addKeyValue("limit", formatNonZero(params.Limit)).
229 addKeyValue("offset", formatNonZero(params.Offset)).
230 build()
231
232 return vr.renderWithParams(v, "View", args, func() string {
233 var meta tools.ViewResponseMetadata
234 if err := vr.unmarshalParams(v.result.Metadata, &meta); err != nil {
235 return renderPlainContent(v, v.result.Content)
236 }
237 return renderCodeContent(v, meta.FilePath, meta.Content, params.Offset)
238 })
239}
240
241// formatNonZero returns string representation of non-zero integers, empty string for zero
242func formatNonZero(value int) string {
243 if value == 0 {
244 return ""
245 }
246 return fmt.Sprintf("%d", value)
247}
248
249// -----------------------------------------------------------------------------
250// Edit renderer
251// -----------------------------------------------------------------------------
252
253// editRenderer handles file editing with diff visualization
254type editRenderer struct {
255 baseRenderer
256}
257
258// Render displays the edited file with a formatted diff of changes
259func (er editRenderer) Render(v *toolCallCmp) string {
260 var params tools.EditParams
261 var args []string
262 if err := er.unmarshalParams(v.call.Input, ¶ms); err == nil {
263 file := fsext.PrettyPath(params.FilePath)
264 args = newParamBuilder().addMain(file).build()
265 }
266
267 return er.renderWithParams(v, "Edit", args, func() string {
268 var meta tools.EditResponseMetadata
269 if err := er.unmarshalParams(v.result.Metadata, &meta); err != nil {
270 return renderPlainContent(v, v.result.Content)
271 }
272
273 formatter := core.DiffFormatter().
274 Before(fsext.PrettyPath(params.FilePath), meta.OldContent).
275 After(fsext.PrettyPath(params.FilePath), meta.NewContent).
276 Width(v.textWidth() - 2) // -2 for padding
277 if v.textWidth() > 120 {
278 formatter = formatter.Split()
279 }
280 return formatter.String()
281 })
282}
283
284// -----------------------------------------------------------------------------
285// Write renderer
286// -----------------------------------------------------------------------------
287
288// writeRenderer handles file writing with syntax-highlighted content preview
289type writeRenderer struct {
290 baseRenderer
291}
292
293// Render displays the file being written with syntax highlighting
294func (wr writeRenderer) Render(v *toolCallCmp) string {
295 var params tools.WriteParams
296 var args []string
297 var file string
298 if err := wr.unmarshalParams(v.call.Input, ¶ms); err == nil {
299 file = fsext.PrettyPath(params.FilePath)
300 args = newParamBuilder().addMain(file).build()
301 }
302
303 return wr.renderWithParams(v, "Write", args, func() string {
304 return renderCodeContent(v, file, params.Content, 0)
305 })
306}
307
308// -----------------------------------------------------------------------------
309// Fetch renderer
310// -----------------------------------------------------------------------------
311
312// fetchRenderer handles URL fetching with format-specific content display
313type fetchRenderer struct {
314 baseRenderer
315}
316
317// Render displays the fetched URL with format and timeout parameters
318func (fr fetchRenderer) Render(v *toolCallCmp) string {
319 var params tools.FetchParams
320 var args []string
321 if err := fr.unmarshalParams(v.call.Input, ¶ms); err == nil {
322 args = newParamBuilder().
323 addMain(params.URL).
324 addKeyValue("format", params.Format).
325 addKeyValue("timeout", formatTimeout(params.Timeout)).
326 build()
327 }
328
329 return fr.renderWithParams(v, "Fetch", args, func() string {
330 file := fr.getFileExtension(params.Format)
331 return renderCodeContent(v, file, v.result.Content, 0)
332 })
333}
334
335// getFileExtension returns appropriate file extension for syntax highlighting
336func (fr fetchRenderer) getFileExtension(format string) string {
337 switch format {
338 case "text":
339 return "fetch.txt"
340 case "html":
341 return "fetch.html"
342 default:
343 return "fetch.md"
344 }
345}
346
347// formatTimeout converts timeout seconds to duration string
348func formatTimeout(timeout int) string {
349 if timeout == 0 {
350 return ""
351 }
352 return (time.Duration(timeout) * time.Second).String()
353}
354
355// -----------------------------------------------------------------------------
356// Glob renderer
357// -----------------------------------------------------------------------------
358
359// globRenderer handles file pattern matching with path filtering
360type globRenderer struct {
361 baseRenderer
362}
363
364// Render displays the glob pattern with optional path parameter
365func (gr globRenderer) Render(v *toolCallCmp) string {
366 var params tools.GlobParams
367 var args []string
368 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
369 args = newParamBuilder().
370 addMain(params.Pattern).
371 addKeyValue("path", params.Path).
372 build()
373 }
374
375 return gr.renderWithParams(v, "Glob", args, func() string {
376 return renderPlainContent(v, v.result.Content)
377 })
378}
379
380// -----------------------------------------------------------------------------
381// Grep renderer
382// -----------------------------------------------------------------------------
383
384// grepRenderer handles content searching with pattern matching options
385type grepRenderer struct {
386 baseRenderer
387}
388
389// Render displays the search pattern with path, include, and literal text options
390func (gr grepRenderer) Render(v *toolCallCmp) string {
391 var params tools.GrepParams
392 var args []string
393 if err := gr.unmarshalParams(v.call.Input, ¶ms); err == nil {
394 args = newParamBuilder().
395 addMain(params.Pattern).
396 addKeyValue("path", params.Path).
397 addKeyValue("include", params.Include).
398 addFlag("literal", params.LiteralText).
399 build()
400 }
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 var args []string
420 if err := lr.unmarshalParams(v.call.Input, ¶ms); err == nil {
421 path := params.Path
422 if path == "" {
423 path = "."
424 }
425 path = fsext.PrettyPath(path)
426
427 args = newParamBuilder().addMain(path).build()
428 }
429
430 return lr.renderWithParams(v, "List", args, func() string {
431 return renderPlainContent(v, v.result.Content)
432 })
433}
434
435// -----------------------------------------------------------------------------
436// Sourcegraph renderer
437// -----------------------------------------------------------------------------
438
439// sourcegraphRenderer handles code search with count and context options
440type sourcegraphRenderer struct {
441 baseRenderer
442}
443
444// Render displays the search query with optional count and context window parameters
445func (sr sourcegraphRenderer) Render(v *toolCallCmp) string {
446 var params tools.SourcegraphParams
447 var args []string
448 if err := sr.unmarshalParams(v.call.Input, ¶ms); err == nil {
449 args = newParamBuilder().
450 addMain(params.Query).
451 addKeyValue("count", formatNonZero(params.Count)).
452 addKeyValue("context", formatNonZero(params.ContextWindow)).
453 build()
454 }
455
456 return sr.renderWithParams(v, "Sourcegraph", args, func() string {
457 return renderPlainContent(v, v.result.Content)
458 })
459}
460
461// -----------------------------------------------------------------------------
462// Diagnostics renderer
463// -----------------------------------------------------------------------------
464
465// diagnosticsRenderer handles project-wide diagnostic information
466type diagnosticsRenderer struct {
467 baseRenderer
468}
469
470// Render displays project diagnostics with plain content formatting
471func (dr diagnosticsRenderer) Render(v *toolCallCmp) string {
472 args := newParamBuilder().addMain("project").build()
473
474 return dr.renderWithParams(v, "Diagnostics", args, func() string {
475 return renderPlainContent(v, v.result.Content)
476 })
477}
478
479// -----------------------------------------------------------------------------
480// Task renderer
481// -----------------------------------------------------------------------------
482
483// agentRenderer handles project-wide diagnostic information
484type agentRenderer struct {
485 baseRenderer
486}
487
488func RoundedEnumerator(children tree.Children, index int) string {
489 if children.Length()-1 == index {
490 return " ╰──"
491 }
492 return " ├──"
493}
494
495// Render displays agent task parameters and result content
496func (tr agentRenderer) Render(v *toolCallCmp) string {
497 t := styles.CurrentTheme()
498 var params agent.AgentParams
499 tr.unmarshalParams(v.call.Input, ¶ms)
500
501 prompt := params.Prompt
502 prompt = strings.ReplaceAll(prompt, "\n", " ")
503
504 header := tr.makeHeader(v, "Agent", v.textWidth())
505 if res, done := earlyState(header, v); done {
506 return res
507 }
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 = t.S().Base.Padding(0, 1).Background(t.Border).Render("Cancelled")
612 case v.result.ToolCallID == "":
613 message = t.S().Base.Padding(0, 1).Background(t.Accent).Foreground(t.FgSubtle).Render("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 errTag := t.S().Base.Padding(0, 1).Background(t.Red).Foreground(t.White).Render("ERROR")
703 err = fmt.Sprintf("%s %s", errTag, t.S().Base.Foreground(t.FgHalfMuted).Render(v.fit(err, v.textWidth()-2-lipgloss.Width(errTag))))
704 return err
705}
706
707func truncateHeight(s string, h int) string {
708 lines := strings.Split(s, "\n")
709 if len(lines) > h {
710 return strings.Join(lines[:h], "\n")
711 }
712 return s
713}
714
715func prettifyToolName(name string) string {
716 switch name {
717 case agent.AgentToolName:
718 return "Agent"
719 case tools.BashToolName:
720 return "Bash"
721 case tools.EditToolName:
722 return "Edit"
723 case tools.FetchToolName:
724 return "Fetch"
725 case tools.GlobToolName:
726 return "Glob"
727 case tools.GrepToolName:
728 return "Grep"
729 case tools.LSToolName:
730 return "List"
731 case tools.SourcegraphToolName:
732 return "Sourcegraph"
733 case tools.ViewToolName:
734 return "View"
735 case tools.WriteToolName:
736 return "Write"
737 default:
738 return name
739 }
740}