ethagent 3.3.3 → 4.0.0

package/src/providers/anthropic.ts

@@ -1,290 +0,0 @@
-import { getKey } from '../storage/secrets.js'
-import type { Message, MessageContentBlock, Provider, ProviderCompleteOptions, StreamEvent } from './contracts.js'
-import { ProviderError } from './contracts.js'
-import { providerErrorFromResponse } from './errors.js'
-import { fetchWithRetryStreamEvents } from './retry.js'
-import { iterSseEvents } from './sse.js'
-import { hasImageBlocks, ImageLoadError, loadImageBlock } from '../utils/images.js'
-
-export type AnthropicToolDefinition = {
-  name: string
-  description: string
-  input_schema: {
-    type: 'object'
-    properties?: Record<string, unknown>
-    required?: string[]
-  }
-}
-
-type AnthropicStreamMessage = {
-  type?: string
-  message?: {
-    usage?: {
-      input_tokens?: number
-      output_tokens?: number
-    }
-  }
-  usage?: {
-    input_tokens?: number
-    output_tokens?: number
-  }
-  delta?: {
-    type?: string
-    text?: string
-    thinking?: string
-    stop_reason?: string
-    partial_json?: string
-  }
-  content_block?: {
-    type?: string
-    id?: string
-    name?: string
-    input?: Record<string, unknown>
-  }
-  index?: number
-  error?: {
-    type?: string
-    message?: string
-  }
-}
-
-const ANTHROPIC_VERSION = '2023-06-01'
-const READ_TIMEOUT_MS = 45_000
-const DEFAULT_MAX_TOKENS = 4096
-
-export class AnthropicProvider implements Provider {
-  readonly id = 'anthropic' as const
-  readonly model: string
-  readonly supportsTools: boolean
-  private readonly tools: AnthropicToolDefinition[]
-
-  constructor(opts: { model: string; tools?: AnthropicToolDefinition[] }) {
-    this.model = opts.model
-    this.tools = opts.tools ?? []
-    this.supportsTools = this.tools.length > 0
-  }
-
-  async *complete(
-    messages: Message[],
-    signal: AbortSignal,
-    options: ProviderCompleteOptions = {},
-  ): AsyncIterable<StreamEvent> {
-    const apiKey = await getKey('anthropic')
-    if (!apiKey) {
-      const error = new ProviderError('missing API key for anthropic (/doctor to verify)')
-      yield { type: 'error', message: error.message }
-      return
-    }
-
-    if (hasImageBlocks(messages) && !supportsAnthropicImages(this.model)) {
-      yield { type: 'error', message: `image input is not enabled for ${this.model}` }
-      return
-    }
-
-    let split: { system?: string; conversation: Awaited<ReturnType<typeof splitMessages>>['conversation'] }
-    try {
-      split = await splitMessages(messages)
-    } catch (err: unknown) {
-      if (err instanceof ImageLoadError) {
-        yield { type: 'error', message: err.message }
-        return
-      }
-      throw err
-    }
-    const { system, conversation } = split
-
-    let response: Response
-    try {
-      response = yield* fetchWithRetryStreamEvents('https://api.anthropic.com/v1/messages', {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          accept: 'text/event-stream',
-          'anthropic-version': ANTHROPIC_VERSION,
-          'x-api-key': apiKey,
-        },
-        body: JSON.stringify({
-          model: this.model,
-          max_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-          stream: true,
-          system,
-          messages: conversation,
-          tools: this.tools.length > 0 ? this.tools : undefined,
-        }),
-      }, { signal, rateLimitResetProvider: 'anthropic' })
-    } catch (err: unknown) {
-      if (signal.aborted) return
-      yield { type: 'error', message: (err as Error).message || 'network error' }
-      return
-    }
-
-    if (!response.ok) {
-      const error = await providerErrorFromResponse(this.id, response)
-      yield { type: 'error', message: error.message }
-      return
-    }
-    if (!response.body) {
-      yield { type: 'error', message: 'empty response body' }
-      return
-    }
-
-    let inputTokens: number | undefined
-    let outputTokens: number | undefined
-    let stopReason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown' = 'unknown'
-    const toolBuffers = new Map<number, { id: string; name: string; json: string }>()
-
-    try {
-      for await (const frame of iterSseEvents(response.body, signal, READ_TIMEOUT_MS)) {
-        const eventType = frame.event
-        let parsed: AnthropicStreamMessage
-        try {
-          parsed = JSON.parse(frame.data) as AnthropicStreamMessage
-        } catch {
-          continue
-        }
-
-        const type = parsed.type ?? eventType ?? ''
-        if (type === 'message_start') {
-          inputTokens = parsed.message?.usage?.input_tokens ?? inputTokens
-          outputTokens = parsed.message?.usage?.output_tokens ?? outputTokens
-          continue
-        }
-        if (type === 'content_block_start' && parsed.content_block?.type === 'tool_use') {
-          const id = parsed.content_block.id ?? `tool-${parsed.index ?? 0}`
-          const name = parsed.content_block.name ?? 'unknown'
-          const json = parsed.content_block.input ? JSON.stringify(parsed.content_block.input) : ''
-          toolBuffers.set(parsed.index ?? 0, { id, name, json })
-          yield { type: 'tool_use_start', id, name }
-          continue
-        }
-        if (type === 'content_block_delta') {
-          if (parsed.delta?.type === 'text_delta' && parsed.delta.text) {
-            yield { type: 'text', delta: parsed.delta.text }
-          } else if (parsed.delta?.type === 'thinking_delta' && parsed.delta.thinking) {
-            yield { type: 'thinking', delta: parsed.delta.thinking }
-          } else if (parsed.delta?.type === 'input_json_delta' && typeof parsed.delta.partial_json === 'string') {
-            const buffer = toolBuffers.get(parsed.index ?? 0)
-            if (buffer) {
-              buffer.json += parsed.delta.partial_json
-              yield { type: 'tool_use_delta', id: buffer.id, delta: parsed.delta.partial_json }
-            }
-          }
-          continue
-        }
-        if (type === 'content_block_stop') {
-          const buffer = toolBuffers.get(parsed.index ?? 0)
-          if (buffer) {
-            let input: Record<string, unknown> = {}
-            try {
-              input = buffer.json.trim() ? JSON.parse(buffer.json) as Record<string, unknown> : {}
-            } catch {
-              input = {}
-            }
-            yield { type: 'tool_use_stop', id: buffer.id, name: buffer.name, input }
-            toolBuffers.delete(parsed.index ?? 0)
-          }
-          continue
-        }
-        if (type === 'message_delta') {
-          inputTokens = parsed.usage?.input_tokens ?? inputTokens
-          outputTokens = parsed.usage?.output_tokens ?? outputTokens
-          stopReason = normalizeStopReason(parsed.delta?.stop_reason)
-          continue
-        }
-        if (type === 'error') {
-          const message = parsed.error?.message || 'anthropic stream error'
-          const transient = parsed.error?.type === 'overloaded_error' || parsed.error?.type === 'rate_limit_error'
-          throw new ProviderError(message, { transient })
-        }
-        if (type === 'message_stop') {
-          break
-        }
-      }
-    } catch (err: unknown) {
-      if (signal.aborted) return
-      yield { type: 'error', message: (err as Error).message || 'stream error' }
-      return
-    }
-
-    if (signal.aborted) return
-    yield { type: 'done', inputTokens, outputTokens, stopReason }
-  }
-}
-
-async function splitMessages(messages: Message[]): Promise<{
-  system?: string
-  conversation: Array<{
-    role: 'user' | 'assistant'
-    content: Array<
-      | { type: 'text'; text: string }
-      | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
-      | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
-      | { type: 'tool_result'; tool_use_id: string; content: string; is_error?: boolean }
-    >
-  }>
-}> {
-  const systemParts: string[] = []
-  const conversation: Array<{
-    role: 'user' | 'assistant'
-    content: Array<
-      | { type: 'text'; text: string }
-      | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
-      | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
-      | { type: 'tool_result'; tool_use_id: string; content: string; is_error?: boolean }
-    >
-  }> = []
-
-  for (const message of messages) {
-    const blocks = normalizeBlocks(message.content)
-    if (blocks.length === 0) continue
-    if (message.role === 'system') {
-      const systemText = blocks.filter(block => block.type === 'text').map(block => block.text).join('\n\n').trim()
-      if (systemText) systemParts.push(systemText)
-      continue
-    }
-    conversation.push({
-      role: message.role,
-      content: await Promise.all(blocks.map(async block => {
-        if (block.type === 'text') return { type: 'text', text: block.text }
-        if (block.type === 'image') {
-          const loaded = await loadImageBlock(block)
-          if (!loaded.dataBase64 || !loaded.mimeType) throw new Error(`could not load image: ${block.path}`)
-          return { type: 'image', source: { type: 'base64', media_type: loaded.mimeType, data: loaded.dataBase64 } }
-        }
-        if (block.type === 'tool_use') return { type: 'tool_use', id: block.id, name: block.name, input: block.input }
-        return { type: 'tool_result', tool_use_id: block.toolUseId, content: block.content, is_error: block.isError }
-      })),
-    })
-  }
-
-  return {
-    system: systemParts.length > 0 ? systemParts.join('\n\n') : undefined,
-    conversation,
-  }
-}
-
-function normalizeBlocks(content: Message['content']): MessageContentBlock[] {
-  if (typeof content === 'string') {
-    const text = content.trim()
-    return text ? [{ type: 'text', text }] : []
-  }
-  return content.filter(block => {
-    if (block.type === 'text') return block.text.trim().length > 0
-    return true
-  })
-}
-
-export function supportsAnthropicImages(model: string): boolean {
-  const normalized = model.toLowerCase()
-  return normalized.includes('claude-3')
-    || normalized.includes('claude-sonnet-4')
-    || normalized.includes('claude-opus-4')
-    || normalized.includes('claude-haiku-4')
-}
-
-function normalizeStopReason(value?: string): 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown' {
-  if (value === 'end_turn' || value === 'tool_use' || value === 'max_tokens' || value === 'stop_sequence') {
-    return value
-  }
-  return 'unknown'
-}

package/src/providers/contracts.ts

@@ -1,71 +0,0 @@
-import type { ProviderId } from '../storage/config.js'
-import type { RetryEvent } from '../utils/withRetry.js'
-
-export type Role = 'system' | 'user' | 'assistant'
-
-export type TextBlock = {
-  type: 'text'
-  text: string
-}
-
-export type ImageBlock = {
-  type: 'image'
-  path: string
-  mimeType?: string
-  url?: string
-  dataBase64?: string
-}
-
-export type ToolUseBlock = {
-  type: 'tool_use'
-  id: string
-  name: string
-  input: Record<string, unknown>
-}
-
-export type ToolResultBlock = {
-  type: 'tool_result'
-  toolUseId: string
-  content: string
-  isError?: boolean
-}
-
-export type MessageContentBlock = TextBlock | ImageBlock | ToolUseBlock | ToolResultBlock
-
-export type Message = {
-  role: Role
-  content: string | MessageContentBlock[]
-}
-
-export type ProviderRetryStreamEvent = { type: 'retry' } & RetryEvent
-
-export type StreamEvent =
-  | { type: 'text'; delta: string }
-  | { type: 'thinking'; delta: string }
-  | { type: 'thinking_end' }
-  | ProviderRetryStreamEvent
-  | { type: 'tool_use_start'; id: string; name: string }
-  | { type: 'tool_use_delta'; id: string; delta: string }
-  | { type: 'tool_use_stop'; id: string; name: string; input: Record<string, unknown> }
-  | { type: 'done'; inputTokens?: number; outputTokens?: number; stopReason?: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'unknown' }
-  | { type: 'error'; message: string }
-
-export type ProviderCompleteOptions = {
-  maxTokens?: number
-}
-
-export interface Provider {
-  readonly id: ProviderId
-  readonly model: string
-  readonly supportsTools: boolean
-  complete(messages: Message[], signal: AbortSignal, options?: ProviderCompleteOptions): AsyncIterable<StreamEvent>
-}
-
-export class ProviderError extends Error {
-  readonly transient: boolean
-  constructor(message: string, options: { transient?: boolean } = {}) {
-    super(message)
-    this.name = 'ProviderError'
-    this.transient = options.transient ?? false
-  }
-}

package/src/providers/errors.ts

@@ -1,80 +0,0 @@
-import type { ProviderId } from '../storage/config.js'
-import { ProviderError } from './contracts.js'
-import { formatGeminiRateLimitMessage } from './gemini.js'
-import { providerDisplayName } from '../models/providerDisplay.js'
-
-type ErrorBody =
-  | string
-  | {
-      error?: {
-        message?: string
-        type?: string
-      }
-      message?: string
-      detail?: string
-    }
-
-export async function providerErrorFromResponse(
-  provider: ProviderId,
-  response: Response,
-): Promise<ProviderError> {
-  if (provider === 'gemini' && response.status === 429) {
-    const short = await formatGeminiRateLimitMessage(response.clone())
-    if (short) return new ProviderError(short, { transient: true })
-  }
-
-  const detail = await readErrorDetail(response)
-
-  if (
-    provider === 'gemini'
-    && response.status === 400
-    && /API[_ ]?key( not valid| not found|_invalid)|invalid api key/i.test(detail)
-  ) {
-    return new ProviderError(
-      'Gemini: API key rejected — verify your key at https://aistudio.google.com/app/apikey, then run /key gemini to set it again',
-    )
-  }
-
-  if (provider !== 'llamacpp') {
-    const name = providerDisplayName(provider)
-    if (response.status === 401 || response.status === 403) {
-      return new ProviderError(`auth failed: check your ${name} key (/doctor to verify)`)
-    }
-    if (response.status === 429) {
-      return new ProviderError(detail || `${name} rate limit exceeded`, { transient: true })
-    }
-    if (response.status >= 500) {
-      return new ProviderError(detail || `${name} server error (${response.status})`, { transient: true })
-    }
-  }
-
-  return new ProviderError(
-    detail ? `HTTP ${response.status}: ${detail}` : `HTTP ${response.status}`,
-    { transient: response.status === 429 || response.status >= 500 },
-  )
-}
-
-async function readErrorDetail(response: Response): Promise<string> {
-  let text = ''
-  try {
-    text = (await response.text()).trim()
-  } catch {
-    return ''
-  }
-  if (!text) return ''
-
-  try {
-    const parsed = JSON.parse(text) as ErrorBody
-    const nestedMessage =
-      typeof parsed === 'object' && parsed !== null
-        ? parsed.error?.message ?? parsed.message ?? parsed.detail ?? ''
-        : ''
-    return normalizeDetail(nestedMessage || text)
-  } catch {
-    return normalizeDetail(text)
-  }
-}
-
-function normalizeDetail(detail: string): string {
-  return detail.replace(/\s+/g, ' ').trim().slice(0, 400)
-}