ethagent 3.3.3 → 4.0.0

package/src/utils/images.ts

@@ -1,140 +0,0 @@
-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/markdownSegments.ts

@@ -1,51 +0,0 @@
-export type Segment =
-  | { kind: 'text'; content: string; preview: string }
-  | { kind: 'code'; lang: string | null; content: string; preview: string }
-
-const FENCE = /^[ \t]{0,3}```([\w+-]*)[ \t]*\r?\n([\s\S]*?)\r?\n[ \t]{0,3}```[ \t]*(?:\r?\n|$)/gm
-
-export function parseSegments(markdown: string): Segment[] {
-  if (!markdown) return []
-  const segments: Segment[] = []
-  let lastIndex = 0
-  FENCE.lastIndex = 0
-  let match: RegExpExecArray | null
-  while ((match = FENCE.exec(markdown)) !== null) {
-    const before = markdown.slice(lastIndex, match.index)
-    const textSeg = toTextSegment(before)
-    if (textSeg) segments.push(textSeg)
-    const lang = match[1] && match[1].length > 0 ? match[1] : null
-    const body = match[2] ?? ''
-    segments.push({
-      kind: 'code',
-      lang,
-      content: body,
-      preview: codePreview(lang, body),
-    })
-    lastIndex = match.index + match[0].length
-  }
-  const tail = markdown.slice(lastIndex)
-  const tailSeg = toTextSegment(tail)
-  if (tailSeg) segments.push(tailSeg)
-  return segments
-}
-
-function toTextSegment(raw: string): Segment | null {
-  const cleaned = raw.replace(/\r\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()
-  if (!cleaned) return null
-  return { kind: 'text', content: cleaned, preview: textPreview(cleaned) }
-}
-
-function textPreview(text: string): string {
-  const firstLine = text.split('\n').find(line => line.trim().length > 0) ?? text
-  const trimmed = firstLine.trim()
-  const chars = text.length
-  const snippet = trimmed.length > 48 ? trimmed.slice(0, 47) + '…' : trimmed
-  return `text · ${chars} chars · ${snippet}`
-}
-
-function codePreview(lang: string | null, body: string): string {
-  const lineCount = body.length === 0 ? 0 : body.split('\n').length
-  const label = lang ?? 'code'
-  return `code · ${label} · ${lineCount} line${lineCount === 1 ? '' : 's'}`
-}

package/src/utils/messages.ts

@@ -1,37 +0,0 @@
-import path from 'node:path'
-import type { Message, MessageContentBlock } from '../providers/contracts.js'
-
-export function systemMessage(content: string): Message {
-  return { role: 'system', content }
-}
-
-export function userMessage(content: string | MessageContentBlock[]): Message {
-  return { role: 'user', content }
-}
-
-export function assistantMessage(content: string | MessageContentBlock[]): Message {
-  return { role: 'assistant', content }
-}
-
-export function messageTextContent(message: Message): string {
-  return typeof message.content === 'string' ? message.content : blocksToText(message.content)
-}
-
-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}]`
-        : `[tool result: ${block.content}]`
-    })
-    .join('\n')
-}
-
-export function approximateTokens(messages: Message[]): number {
-  let chars = 0
-  for (const m of messages) chars += messageTextContent(m).length
-  return Math.ceil(chars / 3)
-}

package/src/utils/withRetry.ts

@@ -1,324 +0,0 @@
-export type RetryClassification = {
-  retryable: boolean
-  retryAfterMs?: number
-  reason: string
-  status?: number
-  code?: string
-}
-
-export type RetryBodyHint = {
-  retryAfterMs?: number
-  fatal?: boolean
-  reason?: string
-}
-
-export type RetryPolicy = {
-  maxRetries: number
-  baseDelayMs: number
-  maxDelayMs: number
-  retryAfterCapMs: number
-  jitterRatio: number
-}
-
-export type RetryEvent = {
-  attempt: number
-  nextAttempt: number
-  maxRetries: number
-  delayMs: number
-  reason: string
-  retryAfterMs?: number
-  status?: number
-  code?: string
-}
-
-const RETRYABLE_NET_CODES = new Set([
-  'ECONNRESET',
-  'EPIPE',
-  'ETIMEDOUT',
-  'ECONNREFUSED',
-  'EHOSTUNREACH',
-  'ENETUNREACH',
-  'EAI_AGAIN',
-])
-
-const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504, 529])
-const DEFAULT_BASE_DELAY_MS = 500
-const DEFAULT_MAX_DELAY_MS = 32_000
-const DEFAULT_JITTER_RATIO = 0.25
-const DEFAULT_MAX_RETRIES = 4
-
-export const DEFAULT_RETRY_POLICY: RetryPolicy = {
-  maxRetries: DEFAULT_MAX_RETRIES,
-  baseDelayMs: DEFAULT_BASE_DELAY_MS,
-  maxDelayMs: DEFAULT_MAX_DELAY_MS,
-  retryAfterCapMs: DEFAULT_MAX_DELAY_MS * 4,
-  jitterRatio: DEFAULT_JITTER_RATIO,
-}
-
-export function classifyRetryableFetchError(err: unknown): RetryClassification {
-  if (!err || typeof err !== 'object') return { retryable: false, reason: 'unknown error' }
-  const code = (err as { code?: unknown }).code
-  if (typeof code === 'string' && RETRYABLE_NET_CODES.has(code)) {
-    return { retryable: true, reason: code, code }
-  }
-  const cause = (err as { cause?: unknown }).cause
-  if (cause && typeof cause === 'object') {
-    const causeCode = (cause as { code?: unknown }).code
-    if (typeof causeCode === 'string' && RETRYABLE_NET_CODES.has(causeCode)) {
-      return { retryable: true, reason: causeCode, code: causeCode }
-    }
-  }
-  const message = (err as { message?: unknown }).message
-  if (typeof message === 'string' && /fetch failed|network|socket hang up|ECONNRESET/i.test(message)) {
-    return { retryable: true, reason: 'fetch failed' }
-  }
-  return { retryable: false, reason: 'non-retryable error' }
-}
-
-export function classifyRetryableResponse(response: Response, nowMs: number = Date.now()): RetryClassification {
-  if (response.ok) return { retryable: false, reason: 'ok', status: response.status }
-  if (!RETRYABLE_STATUS.has(response.status)) {
-    return { retryable: false, reason: `HTTP ${response.status}`, status: response.status }
-  }
-  const retryAfter = response.headers.get('retry-after')
-  const retryAfterMs = retryAfter ? parseRetryAfter(retryAfter, nowMs) : undefined
-  return { retryable: true, retryAfterMs, reason: `HTTP ${response.status}`, status: response.status }
-}
-
-export function classifyRetryableProviderResponse(
-  response: Response,
-  nowMs: number = Date.now(),
-  rateLimitResetProvider?: RateLimitResetProvider,
-): RetryClassification {
-  const classification = classifyRetryableResponse(response, nowMs)
-  if (
-    !classification.retryable ||
-    classification.retryAfterMs !== undefined ||
-    response.status !== 429 ||
-    !rateLimitResetProvider
-  ) {
-    return classification
-  }
-  return {
-    ...classification,
-    retryAfterMs: rateLimitResetDelayMs(response.headers, rateLimitResetProvider, nowMs),
-  }
-}
-
-export function computeBackoffMs(
-  attempt: number,
-  retryAfterMs: number | undefined,
-  maxDelayMs = DEFAULT_MAX_DELAY_MS,
-  baseDelayMs = DEFAULT_BASE_DELAY_MS,
-  rng: () => number = Math.random,
-  jitterRatio = DEFAULT_JITTER_RATIO,
-  retryAfterCapMs = maxDelayMs * 4,
-): number {
-  if (retryAfterMs !== undefined && Number.isFinite(retryAfterMs)) {
-    return Math.min(Math.max(retryAfterMs, 0), retryAfterCapMs)
-  }
-  const expo = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs)
-  const jitter = rng() * jitterRatio * expo
-  return Math.floor(expo + jitter)
-}
-
-export function retryPolicyFromOptions(options: FetchWithRetryOptions = {}): RetryPolicy {
-  const maxDelayMs = options.maxDelayMs ?? DEFAULT_RETRY_POLICY.maxDelayMs
-  return {
-    maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries,
-    baseDelayMs: options.baseDelayMs ?? DEFAULT_RETRY_POLICY.baseDelayMs,
-    maxDelayMs,
-    retryAfterCapMs: options.retryAfterCapMs ?? maxDelayMs * 4,
-    jitterRatio: options.jitterRatio ?? DEFAULT_RETRY_POLICY.jitterRatio,
-  }
-}
-
-export function parseRetryAfter(headerValue: string, nowMs: number = Date.now()): number | undefined {
-  const trimmed = headerValue.trim()
-  if (!trimmed) return undefined
-  const seconds = Number(trimmed)
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
-  const dateMs = Date.parse(trimmed)
-  if (Number.isFinite(dateMs)) return Math.max(0, dateMs - nowMs)
-  return undefined
-}
-
-export function parseOpenAIRateLimitResetMs(value: string): number | undefined {
-  if (!value) return undefined
-  const match = /^(?:(\d+)h)?(?:(\d+)m(?!s))?(?:(\d+)s)?(?:(\d+)ms)?$/.exec(value.trim())
-  if (!match || match[0] === '') return undefined
-  const hours = Number.parseInt(match[1] ?? '0', 10)
-  const minutes = Number.parseInt(match[2] ?? '0', 10)
-  const seconds = Number.parseInt(match[3] ?? '0', 10)
-  const milliseconds = Number.parseInt(match[4] ?? '0', 10)
-  const total = hours * 3_600_000 + minutes * 60_000 + seconds * 1000 + milliseconds
-  return total > 0 ? total : undefined
-}
-
-export type RateLimitResetProvider = 'anthropic' | 'openai-compatible'
-
-export function rateLimitResetDelayMs(
-  headers: Headers,
-  provider: RateLimitResetProvider,
-  nowMs: number = Date.now(),
-  capMs = DEFAULT_RETRY_POLICY.retryAfterCapMs,
-): number | undefined {
-  if (provider === 'anthropic') {
-    const reset = headers.get('anthropic-ratelimit-unified-reset')
-    if (!reset) return undefined
-    const unixSeconds = Number(reset)
-    if (!Number.isFinite(unixSeconds)) return undefined
-    const delay = unixSeconds * 1000 - nowMs
-    return delay > 0 ? Math.min(delay, capMs) : undefined
-  }
-
-  const requestDelay = parseOpenAIRateLimitResetMs(headers.get('x-ratelimit-reset-requests') ?? '')
-  const tokenDelay = parseOpenAIRateLimitResetMs(headers.get('x-ratelimit-reset-tokens') ?? '')
-  const delay = Math.max(requestDelay ?? 0, tokenDelay ?? 0)
-  return delay > 0 ? Math.min(delay, capMs) : undefined
-}
-
-export type FetchWithRetryOptions = {
-  maxRetries?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-  retryAfterCapMs?: number
-  jitterRatio?: number
-  rateLimitResetProvider?: RateLimitResetProvider
-  parseRetryHintFromBody?: (body: string) => RetryBodyHint | undefined
-  signal?: AbortSignal
-  fetchImpl?: typeof fetch
-  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>
-  rng?: () => number
-  now?: () => number
-  onRetry?: (event: RetryEvent) => void
-}
-
-export async function fetchWithRetry(
-  input: string,
-  init: RequestInit,
-  options: FetchWithRetryOptions = {},
-): Promise<Response> {
-  const policy = retryPolicyFromOptions(options)
-  const fetchImpl = options.fetchImpl ?? fetch
-  const sleepImpl = options.sleep ?? sleep
-  const rng = options.rng ?? Math.random
-  const now = options.now ?? Date.now
-  let lastError: unknown
-  for (let attempt = 1; attempt <= policy.maxRetries + 1; attempt += 1) {
-    if (options.signal?.aborted) throw new DOMException('aborted', 'AbortError')
-
-    try {
-      const response = await fetchImpl(input, { ...init, signal: options.signal })
-      if (response.ok) return response
-
-      let classification = classifyRetryableProviderResponse(response, now(), options.rateLimitResetProvider)
-      let bufferedResponse: Response | undefined
-      if (
-        classification.retryable
-        && response.status === 429
-        && options.parseRetryHintFromBody
-      ) {
-        let bodyText = ''
-        try { bodyText = await response.text() } catch {}
-        bufferedResponse = new Response(bodyText, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: response.headers,
-        })
-        const hint = bodyText ? safeParseRetryHint(bodyText, options.parseRetryHintFromBody) : undefined
-        if (hint?.fatal) {
-          return bufferedResponse
-        }
-        if (hint?.retryAfterMs !== undefined) {
-          classification = { ...classification, retryAfterMs: hint.retryAfterMs }
-        }
-        if (hint?.reason) {
-          classification = { ...classification, reason: `${classification.reason} ${hint.reason}` }
-        }
-      }
-      if (!classification.retryable || attempt > policy.maxRetries) return bufferedResponse ?? response
-
-      if (!bufferedResponse) {
-        try { await response.body?.cancel() } catch {}
-      }
-      const delayMs = computeBackoffMs(
-        attempt,
-        classification.retryAfterMs,
-        policy.maxDelayMs,
-        policy.baseDelayMs,
-        rng,
-        policy.jitterRatio,
-        policy.retryAfterCapMs,
-      )
-      options.onRetry?.(retryEvent(attempt, policy.maxRetries, delayMs, classification))
-      await sleepImpl(delayMs, options.signal)
-      continue
-    } catch (err) {
-      lastError = err
-      if (options.signal?.aborted) throw err
-      const classification = classifyRetryableFetchError(err)
-      if (!classification.retryable || attempt > policy.maxRetries) throw err
-
-      const delayMs = computeBackoffMs(
-        attempt,
-        classification.retryAfterMs,
-        policy.maxDelayMs,
-        policy.baseDelayMs,
-        rng,
-        policy.jitterRatio,
-        policy.retryAfterCapMs,
-      )
-      options.onRetry?.(retryEvent(attempt, policy.maxRetries, delayMs, classification))
-      await sleepImpl(delayMs, options.signal)
-    }
-  }
-  throw lastError ?? new Error('fetchWithRetry exhausted')
-}
-
-function safeParseRetryHint(
-  body: string,
-  parser: (body: string) => RetryBodyHint | undefined,
-): RetryBodyHint | undefined {
-  try {
-    return parser(body)
-  } catch {
-    return undefined
-  }
-}
-
-function retryEvent(
-  attempt: number,
-  maxRetries: number,
-  delayMs: number,
-  classification: RetryClassification,
-): RetryEvent {
-  return {
-    attempt,
-    nextAttempt: attempt + 1,
-    maxRetries,
-    delayMs,
-    reason: classification.reason,
-    ...(classification.retryAfterMs !== undefined ? { retryAfterMs: classification.retryAfterMs } : {}),
-    ...(classification.status !== undefined ? { status: classification.status } : {}),
-    ...(classification.code !== undefined ? { code: classification.code } : {}),
-  }
-}
-
-export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(new DOMException('aborted', 'AbortError'))
-      return
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }, ms)
-    const onAbort = () => {
-      clearTimeout(timer)
-      reject(new DOMException('aborted', 'AbortError'))
-    }
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}