}
}
func TestWriteITermImage(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 4))
	img.SetGray(0, 0, color.Gray{Y: 128})
	var buf strings.Builder
	if err := WriteITermImage(img, &buf); err != nil {
		t.Fatalf("WriteITermImage: %v", err)
	}
	out := buf.String()
	if !strings.HasPrefix(out, "\x1b]1337;File=") {
		t.Errorf("expected iTerm2 OSC prefix, got %q", out[:min(30, len(out))])
	}
	if !strings.Contains(out, "inline=1") {
		t.Error("expected inline=1 parameter")
	}
	if !strings.HasSuffix(out, "\x07") {
		t.Error("expected BEL terminator")
	}
}
func TestWriteImage_ITerm(t *testing.T) {
	img := image.NewGray(image.Rect(0, 0, 4, 4))
	var buf strings.Builder
	if err := WriteImage(img, &buf, ProtocolITerm); err != nil {
		t.Fatalf("WriteImage iterm: %v", err)
	}
	if !strings.HasPrefix(buf.String(), "\x1b]1337;File=") {
		t.Error("expected iTerm2 OSC prefix")
	}
}
func TestClearImages_ITerm(t *testing.T) {
	var buf strings.Builder
	ClearImages(&buf, ProtocolITerm)
	if buf.String() != "" {
		t.Errorf("expected no output for iTerm2 clear, got %q", buf.String())

	"encoding/base64"

	"image/png"

	"github.com/charmbracelet/x/ansi/iterm2"

	ProtocolITerm

	case ProtocolITerm:
		return WriteITermImage(img, w)

// For kitty, deletes all image placements. For sixel, no-op (inline text).

// For kitty, deletes all image placements. For sixel/iTerm2, no-op (inline text).

	case ProtocolSixel:

	case ProtocolKitty:
		return ClearKittyImages(w)
	default:

	default:
		return ClearKittyImages(w)

	return err
}
// WriteITermImage writes an image using the iTerm2 Inline Image Protocol.
func WriteITermImage(img image.Image, w io.Writer) error {
	var buf bytes.Buffer
	if err := png.Encode(&buf, img); err != nil {
		return err
	}
	b64 := base64.StdEncoding.EncodeToString(buf.Bytes())
	_, err := io.WriteString(w, ansi.ITerm2(iterm2.File{
		Inline:  true,
		Content: []byte(b64),
	}))

	if m.state.Config.ITerm {
		return utils.ProtocolITerm
	}

	if m.protocol() == utils.ProtocolSixel {
		return sixelImageCmd(m.state)

	if m.protocol() != utils.ProtocolKitty {
		return inlineImageCmd(m.state, m.protocol())

// For sixel: sequence clear screen then write sixel (runs after View renders).

// For inline protocols (sixel/iTerm2): sequence clear screen then write image (runs after View renders).

	if m.protocol() == utils.ProtocolSixel {
		return tea.Sequence(tea.ClearScreen, sixelImageCmd(m.state))

	if m.protocol() != utils.ProtocolKitty {
		return tea.Sequence(tea.ClearScreen, inlineImageCmd(m.state, m.protocol()))

	// Spectrogram image at bottom (kitty only — sixel is written via command)

	// Spectrogram image at bottom (kitty only — inline protocols are written via command)

// sixelImageCmd returns a tea.Cmd that generates and writes a sixel image
// directly to the terminal, bypassing BubbleTea's renderer.
func sixelImageCmd(state *tools.ClassifyState) tea.Cmd {

// inlineImageCmd returns a tea.Cmd that generates and writes an inline image
// (sixel or iTerm2) directly to the terminal, bypassing BubbleTea's renderer.
func inlineImageCmd(state *tools.ClassifyState, protocol utils.ImageProtocol) tea.Cmd {

		utils.WriteSixelImage(img, os.Stdout)

		utils.WriteImage(img, os.Stdout, protocol)

	ITerm        bool   `json:"iterm" jsonschema:"Use iTerm2 inline image protocol"`

	if input.Sixel {

	if input.ITerm {
		protocol = utils.ProtocolITerm
	} else if input.Sixel {

	ITerm     bool

	var color, sixel bool

	var color, sixel, iterm bool

		case "--iterm":
			iterm = true
			i++

		ITerm:     iterm,

	iterm := fs.Bool("iterm", false, "Use iTerm2 inline image protocol")

		fmt.Fprintf(os.Stderr, "Images are output using the Kitty graphics protocol (or Sixel with --sixel).\n\n")

		fmt.Fprintf(os.Stderr, "Images are output using the Kitty graphics protocol (or Sixel with --sixel, iTerm2 with --iterm).\n\n")

		ITerm:        *iterm,

## [2026-03-04] Add iTerm2 Inline Image Protocol Support
**New feature:** Added `--iterm` flag for terminals supporting the iTerm2 Inline Image Protocol (WezTerm, iTerm2, VS Code terminal).
- `utils/terminal_image.go` — Added `ProtocolITerm` enum value and `WriteITermImage()` using charm's `x/ansi/iterm2` package; PNG-encodes then base64-encodes for the iTerm2 escape sequence
- `tools/calls_show_images.go` — Added `ITerm` field to `CallsShowImagesInput`, checked before `Sixel` in protocol selection
- `tools/calls_classify.go` — Added `ITerm` field to `ClassifyConfig`
- `cmd/calls.go` — Added `--iterm` flag to `show-images` subcommand
- `cmd/calls_classify.go` — Added `--iterm` flag to `classify` subcommand
- `tui/classify.go` — Renamed `sixelImageCmd` to `inlineImageCmd` with protocol parameter; changed conditionals from `== ProtocolSixel` to `!= ProtocolKitty` so both sixel and iTerm2 use the same inline rendering path
- `utils/terminal_image_test.go` — Tests for `WriteITermImage`, `WriteImage` routing, and `ClearImages` no-op