ethagent 3.3.4 → 4.0.0

package/src/models/modelPickerCatalogFlow.ts

@@ -1,56 +0,0 @@
-import { createHfDownloadPlan, ggufFiles, loadLocalHfModels } from './huggingface.js'
-import { fetchUncensoredGgufCatalog, type UncensoredCatalogEntry } from './uncensoredCatalog.js'
-import { chooseInstalledHfModelForRepo } from './modelPickerHfFlow.js'
-import { loadHfPickerModels } from './modelPickerData.js'
-import type { LoadedModelPickerData as LoadedData, ModelPickerState as State } from './modelPickerTypes.js'
-
-export async function openLocalCatalog(
-  data: LoadedData,
-  setState: (s: State) => void,
-): Promise<void> {
-  setState({ kind: 'localCatalogLoading', data })
-  try {
-    const installedModels = await loadLocalHfModels()
-    const catalog = await fetchUncensoredGgufCatalog({
-      machineSpec: data.machineSpec,
-      installedModels,
-    })
-    setState({
-      kind: 'localCatalog',
-      data: { ...data, hfModels: await loadHfPickerModels() },
-      catalog,
-    })
-  } catch (err: unknown) {
-    setState({ kind: 'localCatalogError', data, message: (err as Error).message })
-  }
-}
-
-export async function reviewCatalogModel(
-  state: Extract<State, { kind: 'localCatalog' }>,
-  entry: UncensoredCatalogEntry,
-  setState: (s: State) => void,
-): Promise<void> {
-  const files = ggufFiles(entry.repo)
-  const installed = chooseInstalledHfModelForRepo(
-    await loadLocalHfModels(),
-    entry.repo,
-    files,
-    entry.file.filename,
-    state.data.machineSpec,
-  )
-  if (installed) {
-    setState({
-      kind: 'hfDone',
-      data: { ...state.data, hfModels: await loadHfPickerModels() },
-      model: installed,
-      alreadyInstalled: true,
-    })
-    return
-  }
-  try {
-    const plan = await createHfDownloadPlan(entry.repo.repoId, entry.file.filename)
-    setState({ kind: 'hfReview', data: state.data, plan })
-  } catch (err: unknown) {
-    setState({ kind: 'hfError', data: state.data, message: (err as Error).message, input: entry.repo.repoId })
-  }
-}

package/src/models/modelPickerCredentials.ts

@@ -1,166 +0,0 @@
-import type React from 'react'
-import { OpenAIOAuthService } from '../auth/openaiOAuth/index.js'
-import { hasOpenAIOAuthCredentials, rmOpenAIOAuthCredentials } from '../auth/openaiOAuth/credentials.js'
-import { openExternalUrl } from '../utils/openExternal.js'
-import { hasKey, rmKey, setKey } from '../storage/secrets.js'
-import type { EthagentConfig, ProviderId } from '../storage/config.js'
-import {
-  clearModelCatalogCache,
-  discoverProviderModels,
-  isOpenAIOAuthAllowedModel,
-  OPENAI_OAUTH_DEFAULT_MODEL,
-} from './catalog.js'
-import type { CloudCredentialKind, CloudProviderId } from './modelPickerOptions.js'
-import type {
-  LoadedModelPickerData as LoadedData,
-  ModelPickerSelection,
-  ModelPickerState as State,
-} from './modelPickerTypes.js'
-import { configForProvider, pickFallbackSelection } from './modelPickerViewHelpers.js'
-
-export async function submitKey(
-  state: Extract<State, { kind: 'keyEntry' }>,
-  value: string,
-  currentConfig: EthagentConfig,
-  setState: (s: State) => void,
-): Promise<void> {
-  const trimmed = value.trim()
-  if (!trimmed) {
-    setState({ ...state, error: 'key cannot be empty' })
-    return
-  }
-  setState({ ...state, submitting: true, error: undefined })
-  try {
-    await setKey(state.provider, trimmed)
-    const data = await refreshProviderKeyState(state.data, currentConfig, state.provider)
-    setState({ kind: 'list', data })
-  } catch (err: unknown) {
-    setState({ ...state, submitting: false, error: (err as Error).message })
-  }
-}
-
-export async function startOpenAIOAuthFlow(
-  data: LoadedData,
-  currentConfig: EthagentConfig,
-  setState: (s: State) => void,
-  serviceRef: React.MutableRefObject<OpenAIOAuthService | null>,
-  onPick: (sel: ModelPickerSelection) => void,
-): Promise<void> {
-  serviceRef.current?.cleanup()
-  const service = new OpenAIOAuthService()
-  serviceRef.current = service
-  setState({ kind: 'oauthLogin', data, phase: 'waiting' })
-  try {
-    const result = await service.start(authUrl => {
-      openExternalUrl(authUrl)
-      setState({ kind: 'oauthLogin', data, phase: 'waiting', url: authUrl })
-    })
-    if (serviceRef.current !== service) return
-    setState({ kind: 'oauthLogin', data, phase: 'exchanging' })
-    if (result.kind === 'apikey') {
-      if (typeof result.apiKey !== 'string' || result.apiKey.length === 0) {
-        throw new Error(`OAuth result was apikey kind but apiKey is ${typeof result.apiKey}; refusing to store.`)
-      }
-      try {
-        await setKey('openai', result.apiKey)
-      } catch (err) {
-        throw new Error(`Storing the OpenAI API key failed: ${err instanceof Error ? err.message : String(err)}`)
-      }
-    }
-    let refreshed: LoadedData
-    try {
-      refreshed = await refreshProviderKeyState(data, currentConfig, 'openai')
-    } catch (err) {
-      throw new Error(`Refreshing the OpenAI provider state failed: ${err instanceof Error ? err.message : String(err)}`)
-    }
-    if (serviceRef.current !== service) return
-    serviceRef.current = null
-    if (result.kind === 'oauth-only' && !isOpenAIOAuthAllowedModel(currentConfig.model)) {
-      onPick({ kind: 'cloud', provider: 'openai', model: OPENAI_OAUTH_DEFAULT_MODEL, keyJustSet: true })
-      return
-    }
-    setState({ kind: 'list', data: refreshed })
-  } catch (err: unknown) {
-    if (serviceRef.current !== service) return
-    serviceRef.current = null
-    const message = err instanceof Error ? err.message : String(err)
-    if (message === 'OpenAI sign-in was cancelled.') {
-      setState({ kind: 'list', data })
-      return
-    }
-    setState({ kind: 'oauthLogin', data, phase: 'error', message })
-  }
-}
-
-export async function deleteKey(
-  state: Extract<State, { kind: 'keyManage' }>,
-  currentConfig: EthagentConfig,
-  setState: (s: State) => void,
-  onPick: (sel: ModelPickerSelection) => void,
-  currentProvider: ProviderId,
-): Promise<void> {
-  setState({ ...state, submitting: true, error: undefined })
-  try {
-    await rmKey(state.provider)
-    if (state.provider === 'openai') await rmOpenAIOAuthCredentials()
-    const data = await refreshProviderKeyState(state.data, currentConfig, state.provider)
-    if (currentProvider === state.provider) {
-      const fallback = pickFallbackSelection(data, state.provider)
-      if (fallback) {
-        onPick(fallback)
-        return
-      }
-    }
-    setState({ kind: 'list', data })
-  } catch (err: unknown) {
-    setState({ ...state, submitting: false, error: (err as Error).message })
-  }
-}
-
-export async function signOutOAuth(
-  state: Extract<State, { kind: 'oauthManage' }>,
-  currentConfig: EthagentConfig,
-  setState: (s: State) => void,
-  onPick: (sel: ModelPickerSelection) => void,
-  currentProvider: ProviderId,
-): Promise<void> {
-  setState({ ...state, submitting: true, error: undefined })
-  try {
-    await rmKey('openai')
-    await rmOpenAIOAuthCredentials()
-    const data = await refreshProviderKeyState(state.data, currentConfig, 'openai')
-    if (currentProvider === 'openai') {
-      const fallback = pickFallbackSelection(data, 'openai')
-      if (fallback) {
-        onPick(fallback)
-        return
-      }
-    }
-    setState({ kind: 'list', data })
-  } catch (err: unknown) {
-    setState({ ...state, submitting: false, error: (err as Error).message })
-  }
-}
-
-async function refreshProviderKeyState(
-  data: LoadedData,
-  currentConfig: EthagentConfig,
-  provider: CloudProviderId,
-): Promise<LoadedData> {
-  clearModelCatalogCache()
-  const apiKeySet = await hasKey(provider)
-  const oauthSet = provider === 'openai' ? await hasOpenAIOAuthCredentials() : false
-  const keySet = apiKeySet || oauthSet
-  const cloudKeys = { ...data.cloudKeys, [provider]: keySet }
-  const cloudCredentialKinds: Partial<Record<ProviderId, CloudCredentialKind>> = { ...(data.cloudCredentialKinds ?? {}) }
-  if (oauthSet) cloudCredentialKinds[provider] = 'oauth'
-  else if (apiKeySet) cloudCredentialKinds[provider] = 'apikey'
-  else delete cloudCredentialKinds[provider]
-  const cloudCatalogs = { ...data.cloudCatalogs }
-  if (keySet) {
-    cloudCatalogs[provider] = await discoverProviderModels(configForProvider(currentConfig, provider))
-  } else {
-    delete cloudCatalogs[provider]
-  }
-  return { ...data, cloudKeys, cloudCatalogs, cloudCredentialKinds }
-}

package/src/models/modelPickerData.ts

@@ -1,41 +0,0 @@
-import { detectLlamaCpp } from './llamacpp.js'
-import { backfillMmprojForModels, loadLocalHfModels } from './huggingface.js'
-import type { LoadedModelPickerData } from './modelPickerTypes.js'
-import type { ModelPickerOptionsData } from './modelPickerOptions.js'
-
-export async function loadHfPickerModels(): Promise<ModelPickerOptionsData['hfModels']> {
-  const installed = await loadLocalHfModels()
-  const backfilled = await backfillMmprojForModels(installed)
-  return backfilled.map(model => ({
-    id: model.id,
-    displayName: model.displayName,
-    sizeBytes: model.sizeBytes,
-    quantization: model.quantization,
-    risk: model.risk,
-    task: model.task,
-    status: model.status,
-    mmprojPath: model.mmprojPath,
-    mmprojAvailable: model.mmprojAvailable,
-    mmprojSizeBytes: model.mmprojSizeBytes,
-  }))
-}
-
-export async function probeLlamaCpp(): Promise<ModelPickerOptionsData['llamaCpp']> {
-  try {
-    const status = await detectLlamaCpp()
-    return {
-      binaryPresent: status.binaryPresent,
-      serverUp: status.serverUp,
-    }
-  } catch (err: unknown) {
-    return { binaryPresent: false, serverUp: false, error: (err as Error).message }
-  }
-}
-
-export async function refreshLocalModelData(data: LoadedModelPickerData): Promise<LoadedModelPickerData> {
-  const hfModels = await loadHfPickerModels()
-  return {
-    ...data,
-    hfModels,
-  }
-}

package/src/models/modelPickerDisplay.tsx

@@ -1,132 +0,0 @@
-import React from 'react'
-import { Spinner } from '../ui/Spinner.js'
-import { theme } from '../ui/theme.js'
-import { contextWindowInfo } from '../runtime/compaction.js'
-import type { ProviderId } from '../storage/config.js'
-import type { HfCredibility, HfRisk } from './huggingface.js'
-import type { GgufMachineFit } from './modelRecommendation.js'
-import type { CloudProviderId, ModelPickerContextFit } from './modelPickerOptions.js'
-
-export function contextFitSubtitle(contextFit: ModelPickerContextFit): string {
-  const threshold = contextFit.thresholdPercent ?? 90
-  return `pending prompt needs ~${formatTokens(contextFit.usedTokens)} tokens; choose a model under ${threshold}% or use /compact.`
-}
-
-export function contextFitLabel(
-  provider: ProviderId,
-  model: string,
-  baseLabel: string,
-  contextFit?: ModelPickerContextFit | null,
-): string {
-  if (!contextFit) return baseLabel
-  const info = contextWindowInfo(provider, model)
-  const percent = info.tokens > 0 ? Math.round((contextFit.usedTokens / info.tokens) * 100) : 0
-  return `${baseLabel}  ${formatContextWindow(info.tokens)} ctx ${percent}%`
-}
-
-function formatTokens(count: number): string {
-  if (count < 1000) return String(count)
-  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`
-  return `${Math.round(count / 1000)}k`
-}
-
-function formatContextWindow(tokens: number): string {
-  if (tokens >= 1_000_000) {
-    const millions = tokens / 1_000_000
-    return Number.isInteger(millions) ? `${millions}m` : `${millions.toFixed(1)}m`
-  }
-  if (tokens >= 1000) return `${Math.round(tokens / 1000)}k`
-  return String(tokens)
-}
-
-export function formatBytes(bytes: number): string {
-  if (bytes <= 0) return 'size unknown'
-  const gb = bytes / 1e9
-  if (gb >= 1) return `${gb.toFixed(1)} GB`
-  return `${Math.round(bytes / 1e6)} MB`
-}
-
-export function modelMetadataSubtext(size: string, indicators: string[]): string | undefined {
-  return [size, ...indicators].filter(Boolean).join(' · ') || undefined
-}
-
-export function riskColor(risk: string): string {
-  if (risk === 'high') return theme.accentError
-  if (risk === 'medium') return theme.dim
-  return theme.accentPeriwinkle
-}
-
-export function fitColor(fit: GgufMachineFit): string {
-  if (fit === 'too-large') return theme.accentError
-  if (fit === 'tight') return theme.accentPeriwinkle
-  return theme.dim
-}
-
-export function fitLabel(fit: GgufMachineFit, recommended: boolean): string {
-  if (recommended && fit !== 'too-large') return 'Recommended for this machine'
-  if (recommended) return 'Best match found; may be too large'
-  return fileFitHint(fit)
-}
-
-function fileFitHint(fit: GgufMachineFit): string {
-  switch (fit) {
-    case 'fits': return 'Fits this machine'
-    case 'tight': return 'May be slow or tight on memory'
-    case 'too-large': return 'Likely too large for this machine'
-    case 'unknown': return 'machine fit unknown'
-  }
-}
-
-export function formatSignals(downloads: number | undefined, likes: number | undefined): string {
-  const d = downloads == null ? 'downloads unknown' : `${downloads} downloads`
-  const l = likes == null ? 'likes unknown' : `${likes} likes`
-  return `${d}, ${l}`
-}
-
-export function friendlyFileName(filename: string): string {
-  return filename.split('/').pop() ?? filename
-}
-
-export function safetyLabel(risk: HfRisk): string {
-  if (risk === 'low') return 'reviewed'
-  if (risk === 'medium') return 'needs review'
-  return 'blocked'
-}
-
-export function credibilityLabel(credibility: HfCredibility): string {
-  if (credibility === 'established') return 'established'
-  if (credibility === 'normal') return 'some signals'
-  return 'limited signals'
-}
-
-export function friendlyReasons(reasons: string[]): string[] {
-  return reasons.map(reason => {
-    if (reason.includes('compatible local model file')) return 'compatible local model file'
-    if (reason.includes('selected file is not compatible')) return 'file is not compatible with local chat'
-    if (reason.includes('revision is mutable')) return 'model link may point to changing files'
-    if (reason.includes('license is missing')) return 'license is missing'
-    if (reason.includes('limited public usage signals')) return 'source has limited public usage'
-    if (reason.includes('pickle/bin')) return 'repo also contains risky model file formats'
-    return reason
-  })
-}
-
-export function providerKeyPlaceholder(provider: ProviderId): string {
-  if (provider === 'openai') return 'sk-...'
-  if (provider === 'anthropic') return 'sk-ant-...'
-  if (provider === 'gemini') return 'AIza...'
-  return ''
-}
-
-export function runnerPathPlaceholder(): string {
-  if (process.platform === 'win32') return 'C:\\path\\to\\llama-server.exe'
-  return '/path/to/llama-server'
-}
-
-export function isCloudProvider(value: string | undefined): value is CloudProviderId {
-  return value === 'openai' || value === 'anthropic' || value === 'gemini'
-}
-
-export const ElapsedSpinner: React.FC<{ startedAt: number; label: string }> = ({ startedAt, label }) => {
-  return <Spinner label={label} startedAt={startedAt} />
-}

package/src/models/modelPickerHfFlow.ts

@@ -1,192 +0,0 @@
-import React from 'react'
-import {
-  addMmprojToInstalledModel,
-  createHfDownloadPlan,
-  downloadHfModel,
-  fetchHuggingFaceRepoInfo,
-  findLocalHfModel,
-  ggufFiles,
-  loadLocalHfModels,
-  modelFromPlan,
-  parseHuggingFaceRef,
-  type HuggingFaceRepoInfo,
-  type HuggingFaceSibling,
-  type LocalHfModel,
-} from './huggingface.js'
-import { stopLlamaCppServer } from './llamacpp.js'
-import { orderGgufFilesForSpec, recommendGgufFile } from './modelRecommendation.js'
-import type { SpecSnapshot } from './runtimeDetection.js'
-import type { ModelPickerSelection, ModelPickerState as State } from './modelPickerTypes.js'
-import { loadHfPickerModels } from './modelPickerData.js'
-import { startAndPickHfModel } from './modelPickerLocalRunnerFlow.js'
-export async function findInstalledHfModelForInput(input: string): Promise<LocalHfModel | null> {
-  const ref = parseHuggingFaceRef(input)
-  const installed = await loadLocalHfModels()
-  return installed.find(model =>
-    model.status === 'ready'
-    && model.repoId === ref.repoId
-    && (!ref.filename || model.filename === ref.filename)
-  ) ?? null
-}
-
-export function chooseInstalledHfModelForRepo(
-  installed: LocalHfModel[],
-  repo: HuggingFaceRepoInfo,
-  files: HuggingFaceSibling[],
-  requestedFilename: string | undefined,
-  spec: SpecSnapshot | undefined,
-): LocalHfModel | null {
-  const compatibleFiles = new Set(files.map(file => file.filename))
-  const candidates = installed.filter(model =>
-    model.status === 'ready'
-    && model.repoId === repo.repoId
-    && compatibleFiles.has(model.filename)
-    && (!requestedFilename || model.filename === requestedFilename)
-  )
-  if (requestedFilename || candidates.length <= 1) return candidates[0] ?? null
-
-  const orderedFiles = spec
-    ? orderGgufFilesForSpec(repo, files, spec).map(item => item.file.filename)
-    : files.map(file => file.filename)
-  for (const filename of orderedFiles) {
-    const match = candidates.find(model => model.filename === filename)
-    if (match) return match
-  }
-  return candidates[0] ?? null
-}
-
-export async function inspectHfInput(
-  state: Extract<State, { kind: 'hfInput' }>,
-  value: string,
-  setState: (s: State) => void,
-): Promise<void> {
-  const input = value.trim()
-  if (!input) {
-    setState({ ...state, error: 'paste a model link or repo id' })
-    return
-  }
-  setState({ kind: 'hfLoading', data: state.data, input })
-  try {
-    const ref = parseHuggingFaceRef(input)
-    const repo = await fetchHuggingFaceRepoInfo(ref)
-    const files = ggufFiles(repo)
-    if (files.length === 0) {
-      setState({
-        kind: 'hfInput',
-        data: state.data,
-        error: 'no compatible local model files found; paste a different model link',
-      })
-      return
-    }
-    const installed = chooseInstalledHfModelForRepo(
-      await loadLocalHfModels(),
-      repo,
-      files,
-      ref.filename,
-      state.data.machineSpec,
-    )
-    if (installed) {
-      setState({
-        kind: 'hfDone',
-        data: { ...state.data, hfModels: await loadHfPickerModels() },
-        model: installed,
-        alreadyInstalled: true,
-      })
-      return
-    }
-    const recommendedFilename = state.data.machineSpec
-      ? recommendGgufFile(repo, files, state.data.machineSpec)?.file.filename
-      : files[0]?.filename
-    if (ref.filename || files.length === 1) {
-      const plan = await createHfDownloadPlan(input, ref.filename ?? recommendedFilename)
-      setState({ kind: 'hfReview', data: state.data, plan })
-      return
-    }
-    setState({ kind: 'hfFilePick', data: state.data, input, repo, files })
-  } catch (err: unknown) {
-    setState({ kind: 'hfInput', data: state.data, error: (err as Error).message })
-  }
-}
-
-export async function reviewHfFile(
-  state: Extract<State, { kind: 'hfFilePick' }>,
-  filename: string,
-  setState: (s: State) => void,
-): Promise<void> {
-  setState({ kind: 'hfLoading', data: state.data, input: state.input })
-  try {
-    const installed = chooseInstalledHfModelForRepo(
-      await loadLocalHfModels(),
-      state.repo,
-      state.files,
-      filename,
-      state.data.machineSpec,
-    )
-    if (installed) {
-      setState({
-        kind: 'hfDone',
-        data: { ...state.data, hfModels: await loadHfPickerModels() },
-        model: installed,
-        alreadyInstalled: true,
-      })
-      return
-    }
-    const plan = await createHfDownloadPlan(state.input, filename)
-    setState({ kind: 'hfReview', data: state.data, plan })
-  } catch (err: unknown) {
-    setState({ kind: 'hfError', data: state.data, message: (err as Error).message, input: state.input })
-  }
-}
-
-export async function startHfDownload(
-  state: Extract<State, { kind: 'hfReview' }>,
-  setState: (s: State) => void,
-  abortRef: React.MutableRefObject<AbortController | null>,
-  onPick: (sel: ModelPickerSelection) => void,
-): Promise<void> {
-  const controller = new AbortController()
-  abortRef.current = controller
-  setState({ kind: 'hfDownloading', data: state.data, plan: state.plan, progress: { status: 'starting', completed: 0, total: state.plan.sizeBytes } })
-  try {
-    for await (const progress of downloadHfModel(state.plan, controller.signal)) {
-      if (controller.signal.aborted) return
-      setState({ kind: 'hfDownloading', data: state.data, plan: state.plan, progress })
-    }
-    const model = await findLocalHfModel(`${state.plan.repoId}#${state.plan.filename}`)
-      ?? modelFromPlan(state.plan, undefined, 'ready')
-    const data = {
-      ...state.data,
-      hfModels: await loadHfPickerModels(),
-    }
-    await startAndPickHfModel(model, { kind: 'hfDone', data, model }, setState, onPick)
-  } catch (err: unknown) {
-    if (controller.signal.aborted) return
-    setState({ kind: 'hfError', data: state.data, message: (err as Error).message, input: state.plan.repoId })
-  } finally {
-    abortRef.current = null
-  }
-}
-
-export async function downloadMmprojAndContinue(
-  state: Extract<State, { kind: 'mmprojOffer' }>,
-  setState: (s: State) => void,
-  onPick: (sel: ModelPickerSelection) => void,
-): Promise<void> {
-  setState({ kind: 'mmprojDownloading', data: state.data, model: state.model, progress: { status: 'starting' } })
-  try {
-    for await (const progress of addMmprojToInstalledModel(state.model.id)) {
-      setState({ kind: 'mmprojDownloading', data: state.data, model: state.model, progress })
-    }
-  } catch (err: unknown) {
-    setState({ kind: 'mmprojError', data: state.data, model: state.model, message: (err as Error).message })
-    return
-  }
-  const updated = await findLocalHfModel(state.model.id)
-  if (!updated || !updated.mmprojPath) {
-    setState({ kind: 'mmprojError', data: state.data, model: state.model, message: 'projector downloaded but path was not persisted' })
-    return
-  }
-  await stopLlamaCppServer().catch(() => null)
-  const data = { ...state.data, hfModels: await loadHfPickerModels() }
-  await startAndPickHfModel(updated, { kind: 'mmprojOffer', data, model: updated }, setState, onPick)
-}