ethagent 3.0.1 → 3.1.0

package/src/models/llamacppOutput.ts

@@ -0,0 +1,65 @@
+import type { LlamaCppInstallPlan, LlamaCppInstallResult } from './llamacpp.js'
+
+type RunInstallResult = { ok: true } | { ok: false; message: string; detail?: string }
+
+export function summarizeInstallOutput(output: string): string | undefined {
+  const lines = output
+    .split(/\r?\n/)
+    .map(cleanInstallLine)
+    .filter(Boolean)
+    .filter(line => !/^[\-\\|/_.=\s]+$/.test(line))
+    .filter(line => !/^\d+(\.\d+)?\s*(B|KB|MB|GB)\s*\/\s*\d+/i.test(line))
+  const unique = [...new Set(lines)]
+  return unique.slice(-6).join('\n') || undefined
+}
+
+export function humanInstallError(plan: LlamaCppInstallPlan, code: number | null): string {
+  if (plan.command === 'winget') return 'Windows could not install the local runner automatically.'
+  if (plan.command === 'brew') return 'Homebrew could not install the local runner automatically.'
+  if (plan.command === 'nix') return 'Nix could not install the local runner automatically.'
+  if (plan.command === 'port') return 'MacPorts could not install the local runner automatically.'
+  if (plan.command === 'git') return 'ethagent could not download the local runner source.'
+  if (plan.command === 'cmake') return 'ethagent could not build the local runner.'
+  return code === null
+    ? `${plan.label} did not complete.`
+    : `${plan.label} failed with exit code ${code}.`
+}
+
+export function installFailureDetail(code: number | null, output: string): string | undefined {
+  const details = [
+    code === null ? undefined : `exit code ${code}`,
+    summarizeInstallOutput(output),
+  ].filter((item): item is string => Boolean(item))
+  return details.join('\n') || undefined
+}
+
+function cleanInstallLine(line: string): string {
+  return line
+    .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
+    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+export function installerProgressLabel(plan: LlamaCppInstallPlan): string {
+  if (plan.command === 'winget') return 'installing with Windows package manager...'
+  if (plan.command === 'brew') return 'installing with Homebrew...'
+  if (plan.command === 'nix') return 'installing with Nix...'
+  if (plan.command === 'port') return 'installing with MacPorts...'
+  return `installing with ${plan.label}...`
+}
+
+export function formatInstallFailure(label: string, result: RunInstallResult): string {
+  if (result.ok) return label
+  return [label, result.message, result.detail].filter(Boolean).join(': ')
+}
+
+export function buildFailure(result: RunInstallResult): LlamaCppInstallResult {
+  return {
+    ok: false,
+    code: 'build-failed',
+    message: 'ethagent could not build the local runner.',
+    detail: result.ok ? undefined : [result.message, result.detail].filter(Boolean).join('\n'),
+    recovery: ['runner-path', 'retry-install', 'back'],
+  }
+}

package/src/models/modelPickerCatalogFlow.ts

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,192 @@
+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)
+}