ethagent 2.2.0 → 2.4.0

package/src/tools/fileDiff.ts

@@ -0,0 +1,261 @@
+export const DEFAULT_DIFF_CONTEXT_LINES = 3
+export const DEFAULT_DIFF_MAX_CHARS = 2400
+export const FILE_DIFF_RESULT_MARKER = '\n\n<!-- ethagent:file-diff:v1 -->\n'
+
+type DiffOp =
+  | { type: 'equal'; line: string }
+  | { type: 'delete'; line: string }
+  | { type: 'insert'; line: string }
+
+type HunkRange = {
+  start: number
+  end: number
+}
+
+type RenderUnifiedFileDiffInput = {
+  filePath: string
+  before: string
+  after: string
+  contextLines?: number
+  maxChars?: number
+}
+
+const LARGE_DIFF_MATRIX_LIMIT = 500_000
+
+export function renderUnifiedFileDiff(input: RenderUnifiedFileDiffInput): string {
+  const contextLines = input.contextLines ?? DEFAULT_DIFF_CONTEXT_LINES
+  const maxChars = input.maxChars ?? DEFAULT_DIFF_MAX_CHARS
+  const header = [`--- ${input.filePath}`, `+++ ${input.filePath}`]
+
+  if (input.before === input.after) {
+    return header.concat('(no changes)').join('\n')
+  }
+
+  const beforeLines = normalizedLines(input.before)
+  const afterLines = normalizedLines(input.after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  const hunks = buildHunkRanges(ops, contextLines)
+
+  if (hunks.length === 0) {
+    return header.concat('(only line ending changes)').join('\n')
+  }
+
+  const lines = [...header]
+  for (const hunk of hunks) {
+    const oldStart = countOldLines(ops, 0, hunk.start) + 1
+    const newStart = countNewLines(ops, 0, hunk.start) + 1
+    const oldCount = countOldLines(ops, hunk.start, hunk.end)
+    const newCount = countNewLines(ops, hunk.start, hunk.end)
+    lines.push(`@@ -${formatRange(oldStart, oldCount)} +${formatRange(newStart, newCount)} @@`)
+    for (const op of ops.slice(hunk.start, hunk.end)) {
+      if (op.type === 'equal') lines.push(` ${op.line}`)
+      else if (op.type === 'delete') lines.push(`-${op.line}`)
+      else lines.push(`+${op.line}`)
+    }
+  }
+
+  return truncateDiff(lines, maxChars)
+}
+
+export function formatFileChangeResult(content: string, diff: string): string {
+  return `${content}${FILE_DIFF_RESULT_MARKER}${diff}`
+}
+
+export function splitFileChangeResult(content: string): { content: string; diff?: string } {
+  const markerIndex = content.indexOf(FILE_DIFF_RESULT_MARKER)
+  if (markerIndex === -1) return { content }
+  const diff = content.slice(markerIndex + FILE_DIFF_RESULT_MARKER.length).trimEnd()
+  return {
+    content: content.slice(0, markerIndex).trimEnd(),
+    diff: diff.length > 0 ? diff : undefined,
+  }
+}
+
+export function stripFileChangeResultDiff(content: string): string {
+  return splitFileChangeResult(content).content
+}
+
+export function computeLineDiffStats(before: string, after: string): { inserts: number; deletes: number } {
+  if (before === after) return { inserts: 0, deletes: 0 }
+  const beforeLines = normalizedLines(before)
+  const afterLines = normalizedLines(after)
+  const ops = buildLineDiff(beforeLines, afterLines)
+  let inserts = 0
+  let deletes = 0
+  for (const op of ops) {
+    if (op.type === 'insert') inserts += 1
+    else if (op.type === 'delete') deletes += 1
+  }
+  return { inserts, deletes }
+}
+
+function buildLineDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  if (beforeLines.length * afterLines.length > LARGE_DIFF_MATRIX_LIMIT) {
+    return buildPrefixSuffixDiff(beforeLines, afterLines)
+  }
+
+  const lengths = lcsLengths(beforeLines, afterLines)
+  const ops: DiffOp[] = []
+  let beforeIndex = 0
+  let afterIndex = 0
+
+  while (beforeIndex < beforeLines.length && afterIndex < afterLines.length) {
+    const beforeLine = beforeLines[beforeIndex]!
+    const afterLine = afterLines[afterIndex]!
+    if (beforeLine === afterLine) {
+      ops.push({ type: 'equal', line: beforeLine })
+      beforeIndex += 1
+      afterIndex += 1
+      continue
+    }
+
+    const deleteScore = lengths[beforeIndex + 1]![afterIndex]!
+    const insertScore = lengths[beforeIndex]![afterIndex + 1]!
+    const deleteRevealsMatch = beforeLines[beforeIndex + 1] === afterLine
+    const insertRevealsMatch = beforeLine === afterLines[afterIndex + 1]
+
+    if (insertRevealsMatch && insertScore >= deleteScore) {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    } else if (deleteRevealsMatch && deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else if (deleteScore >= insertScore) {
+      ops.push({ type: 'delete', line: beforeLine })
+      beforeIndex += 1
+    } else {
+      ops.push({ type: 'insert', line: afterLine })
+      afterIndex += 1
+    }
+  }
+
+  while (beforeIndex < beforeLines.length) {
+    ops.push({ type: 'delete', line: beforeLines[beforeIndex]! })
+    beforeIndex += 1
+  }
+  while (afterIndex < afterLines.length) {
+    ops.push({ type: 'insert', line: afterLines[afterIndex]! })
+    afterIndex += 1
+  }
+
+  return ops
+}
+
+function buildPrefixSuffixDiff(beforeLines: string[], afterLines: string[]): DiffOp[] {
+  let prefixLength = 0
+  while (
+    prefixLength < beforeLines.length &&
+    prefixLength < afterLines.length &&
+    beforeLines[prefixLength] === afterLines[prefixLength]
+  ) {
+    prefixLength += 1
+  }
+
+  let beforeEnd = beforeLines.length
+  let afterEnd = afterLines.length
+  while (
+    beforeEnd > prefixLength &&
+    afterEnd > prefixLength &&
+    beforeLines[beforeEnd - 1] === afterLines[afterEnd - 1]
+  ) {
+    beforeEnd -= 1
+    afterEnd -= 1
+  }
+
+  const ops: DiffOp[] = []
+  for (let index = 0; index < prefixLength; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < beforeEnd; index += 1) {
+    ops.push({ type: 'delete', line: beforeLines[index]! })
+  }
+  for (let index = prefixLength; index < afterEnd; index += 1) {
+    ops.push({ type: 'insert', line: afterLines[index]! })
+  }
+  for (let index = beforeEnd; index < beforeLines.length; index += 1) {
+    ops.push({ type: 'equal', line: beforeLines[index]! })
+  }
+  return ops
+}
+
+function lcsLengths(beforeLines: string[], afterLines: string[]): number[][] {
+  const lengths = Array.from(
+    { length: beforeLines.length + 1 },
+    () => Array<number>(afterLines.length + 1).fill(0),
+  )
+
+  for (let beforeIndex = beforeLines.length - 1; beforeIndex >= 0; beforeIndex -= 1) {
+    for (let afterIndex = afterLines.length - 1; afterIndex >= 0; afterIndex -= 1) {
+      lengths[beforeIndex]![afterIndex] = beforeLines[beforeIndex] === afterLines[afterIndex]
+        ? lengths[beforeIndex + 1]![afterIndex + 1]! + 1
+        : Math.max(lengths[beforeIndex + 1]![afterIndex]!, lengths[beforeIndex]![afterIndex + 1]!)
+    }
+  }
+
+  return lengths
+}
+
+function buildHunkRanges(ops: DiffOp[], contextLines: number): HunkRange[] {
+  const ranges: HunkRange[] = []
+  const context = Math.max(0, contextLines)
+
+  for (let index = 0; index < ops.length; index += 1) {
+    if (ops[index]?.type === 'equal') continue
+    const start = Math.max(0, index - context)
+    const end = Math.min(ops.length, index + context + 1)
+    const previous = ranges[ranges.length - 1]
+    if (previous && start <= previous.end) {
+      previous.end = Math.max(previous.end, end)
+    } else {
+      ranges.push({ start, end })
+    }
+  }
+
+  return ranges
+}
+
+function countOldLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'delete') count += 1
+  }
+  return count
+}
+
+function countNewLines(ops: DiffOp[], start: number, end: number): number {
+  let count = 0
+  for (let index = start; index < end; index += 1) {
+    const type = ops[index]?.type
+    if (type === 'equal' || type === 'insert') count += 1
+  }
+  return count
+}
+
+function formatRange(start: number, count: number): string {
+  if (count === 0) return `${Math.max(0, start - 1)},0`
+  if (count === 1) return String(start)
+  return `${start},${count}`
+}
+
+function normalizedLines(value: string): string[] {
+  if (value.length === 0) return []
+  const lines = value.replace(/\r\n?/g, '\n').split('\n')
+  if (lines[lines.length - 1] === '') lines.pop()
+  return lines
+}
+
+function truncateDiff(lines: string[], maxChars: number): string {
+  const diff = lines.join('\n')
+  if (diff.length <= maxChars) return diff
+
+  const out: string[] = []
+  let length = 0
+  for (const line of lines) {
+    const nextLength = length + (out.length > 0 ? 1 : 0) + line.length
+    if (nextLength > maxChars) break
+    out.push(line)
+    length = nextLength
+  }
+  return out.join('\n')
+}

package/src/tools/privateContinuityEditTool.ts

@@ -6,6 +6,7 @@ import {
 import { recordPrivateContinuityHistorySnapshot } from '../identity/continuity/history.js'
 import { readContinuityFiles, readPublicSkillsFile } from '../identity/continuity/storage.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult } from './fileDiff.js'
 
 const schema = z.object({
   file: z.preprocess(normalizePrivateContinuityFile, z.enum(['SOUL.md', 'MEMORY.md'])),
@@ -141,7 +142,10 @@ export const privateContinuityEditTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.changeSummary,
-      content: formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+      content: formatFileChangeResult(
+        formatPrivateContinuityEditResult(prepared.file, prepared.fullPath),
+        prepared.diff,
+      ),
     }
   },
 }

package/src/tools/writeFileTool.ts

@@ -4,6 +4,7 @@ import { z } from 'zod'
 import { recordRewindSnapshot } from '../storage/rewind.js'
 import type { EthagentConfig } from '../storage/config.js'
 import type { Tool } from './contracts.js'
+import { formatFileChangeResult, renderUnifiedFileDiff } from './fileDiff.js'
 import { resolveWorkspacePath } from './readTool.js'
 
 const schema = z.object({
@@ -40,6 +41,7 @@ export const writeFileTool: Tool<typeof schema> = {
       subtitle: prepared.fullPath,
       before: previewText(prepared.before),
       after: previewText(input.content),
+      diff: renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
       changeSummary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
     }
   },
@@ -64,9 +66,12 @@ export const writeFileTool: Tool<typeof schema> = {
     return {
       ok: true,
       summary: prepared.existedBefore ? `replace entire ${prepared.relativePath}` : `create ${prepared.relativePath}`,
-      content: rewindWarning
-        ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
-        : `updated ${prepared.fullPath}`,
+      content: formatFileChangeResult(
+        rewindWarning
+          ? `updated ${prepared.fullPath}\nwarning: ${rewindWarning}`
+          : `updated ${prepared.fullPath}`,
+        renderUnifiedFileDiff({ filePath: prepared.relativePath, before: prepared.before, after: input.content }),
+      ),
     }
   },
 }

package/src/ui/Spinner.tsx

@@ -226,6 +226,7 @@ export const Spinner: React.FC<SpinnerProps> = ({
   const stickyVerbRef = useRef<string | null>(null)
   const internalStartedAtRef = useRef<number>(Date.now())
   const [frame, setFrame] = useState(0)
+  const [shimmerPos, setShimmerPos] = useState(0)
 
   useEffect(() => {
     if (!active) {
@@ -252,19 +253,40 @@ export const Spinner: React.FC<SpinnerProps> = ({
     return () => clearInterval(timer)
   }, [active])
 
-  if (!active) return null
-
   const autoLabel = stickyVerbRef.current ?? verb ?? 'thinking'
   const text = spinnerText(label ?? `${autoLabel}…`)
+
+  useEffect(() => {
+    if (!active) return
+    const period = text.length + 12
+    const timer = setInterval(() => {
+      setShimmerPos(prev => (prev + 1) % period)
+    }, 90)
+    return () => clearInterval(timer)
+  }, [active, text.length])
+
+  if (!active) return null
+
   const glyph = FRAMES[frame] ?? 'o'
   const elapsed = showElapsed ? formatElapsedSeconds(Date.now() - (startedAt ?? internalStartedAtRef.current)) : null
   const renderedHint = [rawHint, elapsed].filter(Boolean).join(' · ')
   const hint = renderedHint ? spinnerHintText(renderedHint) : ''
 
+  const shimmerStart = shimmerPos - 1
+  const shimmerEnd = shimmerPos + 1
+  const visibleStart = Math.max(0, shimmerStart)
+  const visibleEnd = Math.min(text.length, shimmerEnd + 1)
+  const before = text.slice(0, visibleStart)
+  const shimmer = shimmerStart < text.length && shimmerEnd >= 0 ? text.slice(visibleStart, visibleEnd) : ''
+  const after = text.slice(visibleEnd)
+
   return (
     <Text>
       <Text color={color}>{glyph}</Text>
-      <Text color={theme.dim}> {text}</Text>
+      <Text> </Text>
+      {before ? <Text color={theme.accentPeriwinkle}>{before}</Text> : null}
+      {shimmer ? <Text color={theme.accentWhite} bold>{shimmer}</Text> : null}
+      {after ? <Text color={theme.accentPeriwinkle}>{after}</Text> : null}
       {hint ? <Text color={theme.dim}> · {hint}</Text> : null}
     </Text>
   )
@@ -273,8 +295,20 @@ export const Spinner: React.FC<SpinnerProps> = ({
 function formatElapsedSeconds(milliseconds: number): string {
   const seconds = Math.max(0, Math.floor(milliseconds / 1000))
   if (seconds < 60) return `${seconds}s`
-  const minutes = Math.floor(seconds / 60)
-  return `${minutes}:${(seconds % 60).toString().padStart(2, '0')}`
+
+  const hours = Math.floor(seconds / 3600)
+  const minutes = Math.floor((seconds % 3600) / 60)
+  const remainingSeconds = seconds % 60
+
+  if (hours > 0) {
+    return remainingSeconds > 0
+      ? `${hours}h ${minutes}min ${remainingSeconds}s`
+      : `${hours}h ${minutes}min`
+  }
+
+  return remainingSeconds > 0
+    ? `${minutes}min ${remainingSeconds}s`
+    : `${minutes}min`
 }
 
 function restoreSpinnerTerms(value: string): string {

package/src/ui/TextInput.tsx

@@ -2,11 +2,11 @@ import React, { useState, useRef, useEffect } from 'react'
 import { Box, Text, useStdout } from 'ink'
 import { theme } from './theme.js'
 import { useAppInput } from '../app/input/AppInputProvider.js'
-import { moveVerticalVisual } from '../chat/chatInputState.js'
+import { moveVerticalVisual } from '../chat/input/chatInputState.js'
 import {
   getVisualLineIndex,
   getVisualLines,
-} from '../chat/textCursor.js'
+} from '../chat/input/textCursor.js'
 
 const DEFAULT_CHROME_WIDTH = 10
 

package/src/ui/theme.ts

@@ -11,6 +11,25 @@ export const theme = {
   accentBlue: '#e8eefd',
   accentWhite: '#f5f8ff',
   accentError: '#d99898',
+  modePlan: '#f0c7a8',
+  modeAcceptEdits: '#c7b6f2',
+  diffAdded: '#8fd49d',
+  diffRemoved: '#d99898',
+  diffAddedBackground: '#16351f',
+  diffRemovedBackground: '#3a1717',
+  blockBackground: '#0b0d12',
+  codeKeyword: '#e8eefd',
+  codeString: '#c9e08f',
+  codeNumber: '#d8dcfa',
+  codeComment: '#777777',
+  codeFunction: '#8fc7ff',
+  codeType: '#f2d087',
+  codeBuiltin: '#b8a7ff',
+  codeProperty: '#91dcc0',
+  codeOperator: '#d8dcfa',
+  codePunctuation: '#aeb4c8',
+  codeTag: '#ffb3b3',
+  codeAttribute: '#f2d087',
   border: '#555555',
   dim: '#777777',
   text: '#f1f1f1',

package/src/utils/clipboard.ts

@@ -3,26 +3,29 @@ import { mkdir, stat } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
-export type CopyResult = { ok: true; method: string } | { ok: false; error: string }
+export type CopyResult = { ok: true; method: string; chars: number } | { ok: false; error: string }
 export type ReadResult = { ok: true; text: string; method: string } | { ok: false; error: string }
 export type ReadImageResult = { ok: true; path: string; method: string } | { ok: false; error: string }
 
+type CopyAttempt = { ok: true; method: string } | { ok: false; error: string }
+
 export async function copyToClipboard(text: string): Promise<CopyResult> {
+  const chars = text.length
   const native = await tryNative(text)
-  if (native.ok) return native
+  if (native.ok) return { ...native, chars }
 
   const tmux = await tryTmux(text)
-  if (tmux.ok) return tmux
+  if (tmux.ok) return { ...tmux, chars }
 
   try {
     process.stdout.write(osc52(text))
-    return { ok: true, method: 'osc52' }
+    return { ok: true, method: 'osc52', chars }
   } catch (err: unknown) {
     return { ok: false, error: (err as Error).message || 'osc52 write failed' }
   }
 }
 
-async function tryNative(text: string): Promise<CopyResult> {
+async function tryNative(text: string): Promise<CopyAttempt> {
   if (process.platform === 'darwin') {
     return pipeTo('pbcopy', [], text, 'pbcopy')
   }
@@ -38,12 +41,12 @@ async function tryNative(text: string): Promise<CopyResult> {
   return { ok: false, error: 'no native clipboard tool found' }
 }
 
-async function tryTmux(text: string): Promise<CopyResult> {
+async function tryTmux(text: string): Promise<CopyAttempt> {
   if (!process.env['TMUX']) return { ok: false, error: 'not in tmux' }
   return pipeTo('tmux', ['load-buffer', '-w', '-'], text, 'tmux load-buffer')
 }
 
-function pipeTo(cmd: string, args: string[], text: string, method: string): Promise<CopyResult> {
+function pipeTo(cmd: string, args: string[], text: string, method: string): Promise<CopyAttempt> {
   return new Promise(resolve => {
     let child
     try {

package/src/utils/images.ts

@@ -0,0 +1,140 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import type { ImageBlock, Message, MessageContentBlock } from '../providers/contracts.js'
+
+const IMAGE_MARKER_RE = /\[image:\s*([^\]]+?)\]/gi
+const PLACEHOLDER_RE = /^([<{[].*[>}\]]|#\d+)$/
+
+export class ImageLoadError extends Error {
+  readonly imagePath: string
+  constructor(imagePath: string, message: string) {
+    super(message)
+    this.name = 'ImageLoadError'
+    this.imagePath = imagePath
+  }
+}
+
+export function collapseImagePathsToRefs(text: string): string {
+  let counter = 0
+  return text.replace(IMAGE_MARKER_RE, (full, raw: string) => {
+    const trimmed = raw.trim()
+    if (!trimmed || PLACEHOLDER_RE.test(trimmed)) return full
+    counter += 1
+    return `[Image #${counter}]`
+  })
+}
+
+export function modelSupportsImages(
+  provider: string,
+  model: string,
+  extra?: { mmprojPath?: string },
+): boolean {
+  const normalized = model.toLowerCase()
+  switch (provider) {
+    case 'anthropic':
+      return /claude-3|claude-sonnet-4|claude-opus-4|claude-haiku-4/.test(normalized)
+    case 'gemini':
+      return /gemini-1\.5|gemini-2\.0|gemini-2\.5/.test(normalized)
+    case 'openai':
+      if (normalized.includes('gpt-3.5')) return false
+      return /gpt-4o|gpt-4\.1|gpt-4-turbo|gpt-4-vision|gpt-5|o1|o3|o4|chatgpt-4/.test(normalized)
+    case 'llamacpp':
+      return Boolean(extra?.mmprojPath)
+    default:
+      return false
+  }
+}
+
+export function hasImageBlocks(messages: Message[]): boolean {
+  return messages.some(message => Array.isArray(message.content) && message.content.some(block => block.type === 'image'))
+}
+
+export function userTextToContentBlocks(text: string): string | MessageContentBlock[] {
+  const blocks = parseImageMarkers(text)
+  return blocks.length === 1 && blocks[0]?.type === 'text' ? blocks[0].text : blocks
+}
+
+export function parseImageMarkers(text: string): MessageContentBlock[] {
+  const out: MessageContentBlock[] = []
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = IMAGE_MARKER_RE.exec(text)) !== null) {
+    const full = match[0]
+    const rawPath = match[1]?.trim() ?? ''
+    if (match.index > lastIndex) {
+      const prefix = text.slice(lastIndex, match.index)
+      if (prefix) out.push({ type: 'text', text: prefix })
+    }
+    if (rawPath && !PLACEHOLDER_RE.test(rawPath)) {
+      out.push({ type: 'image', path: rawPath })
+    } else {
+      out.push({ type: 'text', text: full })
+    }
+    lastIndex = match.index + full.length
+  }
+
+  if (lastIndex < text.length) {
+    const suffix = text.slice(lastIndex)
+    if (suffix) out.push({ type: 'text', text: suffix })
+  }
+
+  if (out.length === 0) return text ? [{ type: 'text', text }] : []
+  return mergeAdjacentTextBlocks(out)
+}
+
+export async function loadImageBlock(block: ImageBlock): Promise<ImageBlock> {
+  if (block.dataBase64 && block.mimeType) return block
+  if (block.url) return block
+  const rawPath = block.path?.trim() ?? ''
+  if (!rawPath) throw new ImageLoadError(rawPath, 'image path is empty')
+  if (PLACEHOLDER_RE.test(rawPath)) {
+    throw new ImageLoadError(rawPath, `image path looks like a placeholder, not a real file: ${rawPath}`)
+  }
+  let file: Buffer
+  try {
+    file = await fs.readFile(rawPath)
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ENOENT') {
+      throw new ImageLoadError(rawPath, `image file not found: ${rawPath}`)
+    }
+    throw new ImageLoadError(rawPath, `could not read image at ${rawPath}: ${(err as Error).message}`)
+  }
+  const mimeType = block.mimeType ?? mimeTypeForPath(rawPath)
+  return {
+    ...block,
+    path: rawPath,
+    mimeType,
+    dataBase64: file.toString('base64'),
+  }
+}
+
+export function imagePlaceholder(pathValue: string): string {
+  return `[image: ${path.basename(pathValue)}]`
+}
+
+function mergeAdjacentTextBlocks(blocks: MessageContentBlock[]): MessageContentBlock[] {
+  const out: MessageContentBlock[] = []
+  for (const block of blocks) {
+    const prev = out[out.length - 1]
+    if (block.type === 'text' && prev?.type === 'text') {
+      prev.text += block.text
+      continue
+    }
+    out.push(block)
+  }
+  return out
+}
+
+function mimeTypeForPath(filePath: string): string {
+  switch (path.extname(filePath).toLowerCase()) {
+    case '.png': return 'image/png'
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg'
+    case '.webp': return 'image/webp'
+    case '.gif': return 'image/gif'
+    case '.bmp': return 'image/bmp'
+    default: return 'application/octet-stream'
+  }
+}

package/src/utils/messages.ts

@@ -1,3 +1,4 @@
+import path from 'node:path'
 import type { Message, MessageContentBlock } from '../providers/contracts.js'
 
 export function systemMessage(content: string): Message {
@@ -20,6 +21,7 @@ export function blocksToText(blocks: MessageContentBlock[]): string {
   return blocks
     .map(block => {
       if (block.type === 'text') return block.text
+      if (block.type === 'image') return `[image attached: ${path.basename(block.path)}]`
       if (block.type === 'tool_use') return `[tool use: ${block.name}]`
       return block.isError
         ? `[tool error: ${block.content}]`