ethagent 3.3.3 → 4.0.0

package/src/models/llamacppCommands.ts

@@ -1,44 +0,0 @@
-import { spawn } from 'node:child_process'
-
-export type RunResult = {
-  code: number
-  stdout: string
-  stderr: string
-}
-
-export function runCommand(cmd: string, args: string[], timeoutMs = 2000): Promise<RunResult | null> {
-  return new Promise(resolve => {
-    let settled = false
-    let child: ReturnType<typeof spawn>
-    try {
-      child = spawn(cmd, args, { windowsHide: true })
-    } catch {
-      resolve(null)
-      return
-    }
-
-    let stdout = ''
-    let stderr = ''
-    const timer = setTimeout(() => {
-      if (settled) return
-      settled = true
-      try { child.kill() } catch { void 0 }
-      resolve(null)
-    }, timeoutMs)
-
-    child.stdout?.on('data', chunk => { stdout += chunk.toString() })
-    child.stderr?.on('data', chunk => { stderr += chunk.toString() })
-    child.on('error', () => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve(null)
-    })
-    child.on('close', code => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve({ code: code ?? -1, stdout, stderr })
-    })
-  })
-}

package/src/models/llamacppConfig.ts

@@ -1,34 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { atomicWriteText } from '../storage/atomicWrite.js'
-import { ensureConfigDir, getConfigDir } from '../storage/config.js'
-
-export type LocalRunnerConfig = {
-  llamaServerPath?: string
-}
-
-export function getLocalRunnerConfigPath(): string {
-  return path.join(getConfigDir(), 'local-runner.json')
-}
-
-export async function loadLocalRunnerConfig(): Promise<LocalRunnerConfig> {
-  try {
-    const raw = await fs.readFile(getLocalRunnerConfigPath(), 'utf8')
-    const parsed = JSON.parse(raw) as unknown
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {}
-    const value = (parsed as { llamaServerPath?: unknown }).llamaServerPath
-    return typeof value === 'string' && value.trim() ? { llamaServerPath: value.trim() } : {}
-  } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return {}
-    return {}
-  }
-}
-
-export async function saveLocalRunnerConfig(config: LocalRunnerConfig): Promise<void> {
-  await ensureConfigDir()
-  await atomicWriteText(getLocalRunnerConfigPath(), JSON.stringify(config, null, 2) + '\n')
-}
-
-export async function setLlamaCppServerPath(serverPath: string): Promise<void> {
-  await saveLocalRunnerConfig({ llamaServerPath: serverPath.trim() })
-}

package/src/models/llamacppDiscovery.ts

@@ -1,176 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getConfigDir } from '../storage/config.js'
-import {
-  loadLocalRunnerConfig,
-  setLlamaCppServerPath,
-} from './llamacppConfig.js'
-import { runCommand } from './llamacppCommands.js'
-
-export async function detectLlamaCppServerBinary(extraCandidates: string[] = []): Promise<{ path: string | null; version: string | null }> {
-  const config = await loadLocalRunnerConfig()
-  const candidates = [
-    ...llamaCppServerCandidates(process.env, process.platform, config.llamaServerPath),
-    ...extraCandidates,
-  ]
-  for (const candidate of candidates) {
-    const result = await runCommand(candidate, ['--version'])
-    if (!result) continue
-    const output = `${result.stdout}\n${result.stderr}`.trim()
-    if (result.code === 0 || output.length > 0) {
-      return { path: candidate, version: firstLine(output) || 'installed' }
-    }
-  }
-  return { path: null, version: null }
-}
-
-export function llamaCppServerCandidates(
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform = process.platform,
-  configuredPath?: string,
-): string[] {
-  const candidates: string[] = []
-  appendCandidate(candidates, configuredPath)
-  appendCandidate(candidates, env.LLAMA_SERVER_PATH)
-  appendCandidate(candidates, env.LLAMACPP_SERVER_PATH)
-  appendCandidate(candidates, 'llama-server')
-  appendCandidate(candidates, 'llama-server.exe')
-
-  if (platform === 'win32') {
-    appendCandidate(candidates, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Programs', 'llama.cpp', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'llama.cpp', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Microsoft', 'WindowsApps', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env.ProgramFiles ? path.join(env.ProgramFiles, 'llama.cpp', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env['ProgramFiles(x86)'] ? path.join(env['ProgramFiles(x86)'], 'llama.cpp', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env.USERPROFILE ? path.join(env.USERPROFILE, 'scoop', 'shims', 'llama-server.exe') : undefined)
-    appendCandidate(candidates, env.USERPROFILE ? path.join(env.USERPROFILE, 'scoop', 'apps', 'llama.cpp', 'current', 'llama-server.exe') : undefined)
-  } else if (platform === 'darwin') {
-    appendCandidate(candidates, '/opt/homebrew/bin/llama-server')
-    appendCandidate(candidates, '/usr/local/bin/llama-server')
-    appendCandidate(candidates, '/opt/local/bin/llama-server')
-    appendCandidate(candidates, env.HOME ? path.join(env.HOME, '.nix-profile', 'bin', 'llama-server') : undefined)
-    appendCandidate(candidates, env.HOME ? path.join(env.HOME, '.local', 'bin', 'llama-server') : undefined)
-  } else {
-    appendCandidate(candidates, '/usr/local/bin/llama-server')
-    appendCandidate(candidates, '/usr/bin/llama-server')
-    appendCandidate(candidates, env.HOME ? path.join(env.HOME, '.nix-profile', 'bin', 'llama-server') : undefined)
-    appendCandidate(candidates, env.HOME ? path.join(env.HOME, '.local', 'bin', 'llama-server') : undefined)
-  }
-
-  return candidates
-}
-
-export function llamaCppSearchRoots(
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform = process.platform,
-): string[] {
-  const roots: string[] = []
-  if (platform === 'win32') {
-    appendCandidate(roots, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Packages') : undefined)
-    appendCandidate(roots, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Microsoft', 'WindowsApps') : undefined)
-    appendCandidate(roots, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'Programs', 'llama.cpp') : undefined)
-    appendCandidate(roots, env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'llama.cpp') : undefined)
-    appendCandidate(roots, env.ProgramFiles ? path.join(env.ProgramFiles, 'llama.cpp') : undefined)
-    appendCandidate(roots, env.ProgramFiles ? path.join(env.ProgramFiles, 'WindowsApps') : undefined)
-    appendCandidate(roots, env.USERPROFILE ? path.join(env.USERPROFILE, 'scoop', 'apps', 'llama.cpp') : undefined)
-    appendCandidate(roots, env.USERPROFILE ? path.join(env.USERPROFILE, 'scoop', 'shims') : undefined)
-    appendCandidate(roots, path.join(getConfigDir(), 'runners', 'llama.cpp', 'build'))
-    appendCandidate(roots, path.join(getConfigDir(), 'runners', 'llama.cpp', 'build', 'bin'))
-    return roots
-  }
-
-  appendCandidate(roots, '/opt/homebrew/bin')
-  appendCandidate(roots, '/usr/local/bin')
-  appendCandidate(roots, '/opt/local/bin')
-  appendCandidate(roots, '/usr/bin')
-  appendCandidate(roots, env.HOME ? path.join(env.HOME, '.nix-profile', 'bin') : undefined)
-  appendCandidate(roots, env.HOME ? path.join(env.HOME, '.local', 'bin') : undefined)
-  appendCandidate(roots, path.join(getConfigDir(), 'runners', 'llama.cpp', 'build'))
-  appendCandidate(roots, path.join(getConfigDir(), 'runners', 'llama.cpp', 'build', 'bin'))
-  return roots
-}
-
-export async function discoverLlamaCppServerPaths(
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform = process.platform,
-): Promise<string[]> {
-  return discoverExecutablePaths(platform === 'win32' ? ['llama-server.exe', 'llama-server'] : ['llama-server'], env, platform)
-}
-
-export async function discoverLlamaCppCliPaths(
-  env: NodeJS.ProcessEnv = process.env,
-  platform: NodeJS.Platform = process.platform,
-): Promise<string[]> {
-  return discoverExecutablePaths(platform === 'win32' ? ['llama-cli.exe', 'llama-cli'] : ['llama-cli'], env, platform)
-}
-
-export async function findAndPersistLlamaCppServer(
-  platform: NodeJS.Platform = process.platform,
-): Promise<{ path: string | null; version: string | null }> {
-  const direct = await detectLlamaCppServerBinary()
-  if (direct.path) return direct
-  const discovered = await discoverLlamaCppServerPaths(process.env, platform)
-  const found = await detectLlamaCppServerBinary(discovered)
-  if (found.path) {
-    await setLlamaCppServerPath(found.path).catch(() => {})
-  }
-  return found
-}
-
-async function discoverExecutablePaths(
-  names: string[],
-  env: NodeJS.ProcessEnv,
-  platform: NodeJS.Platform,
-): Promise<string[]> {
-  const found: string[] = []
-  const lowered = new Set(names.map(name => name.toLowerCase()))
-  for (const root of llamaCppSearchRoots(env, platform)) {
-    await walkForExecutable(root, lowered, found, 0, 5)
-    if (found.length >= 20) break
-  }
-  return found
-}
-
-async function walkForExecutable(
-  dir: string,
-  names: Set<string>,
-  found: string[],
-  depth: number,
-  maxDepth: number,
-): Promise<void> {
-  if (depth > maxDepth || found.length >= 20) return
-  let entries: Array<import('node:fs').Dirent>
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true })
-  } catch {
-    return
-  }
-
-  for (const entry of entries) {
-    if (found.length >= 20) return
-    const fullPath = path.join(dir, entry.name)
-    const lowerName = entry.name.toLowerCase()
-    if ((entry.isFile() || entry.isSymbolicLink()) && names.has(lowerName)) {
-      appendCandidate(found, fullPath)
-      continue
-    }
-    if (entry.isDirectory() && shouldDescendRunnerDir(entry.name, depth)) {
-      await walkForExecutable(fullPath, names, found, depth + 1, maxDepth)
-    }
-  }
-}
-
-function shouldDescendRunnerDir(name: string, depth: number): boolean {
-  const lower = name.toLowerCase()
-  if (/(llama|ggml|bin|build|release|debug|current|package|windowsapps|x64|arm64)/.test(lower)) return true
-  return depth > 0 && lower.length <= 24
-}
-
-function firstLine(text: string): string {
-  return text.split(/\r?\n/).map(line => line.trim()).find(Boolean) ?? ''
-}
-
-function appendCandidate(candidates: string[], candidate: string | undefined): void {
-  if (!candidate || candidates.includes(candidate)) return
-  candidates.push(candidate)
-}

package/src/models/llamacppOutput.ts

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

@@ -1,158 +0,0 @@
-import {
-  fetchLlamaCppContextSize,
-  startLlamaCppServer,
-  stopLlamaCppServer,
-  type LlamaCppStartFailureCode,
-  type LlamaCppStartResult,
-} from './llamacpp.js'
-import { findLocalHfModel, type LocalHfModel } from './huggingface.js'
-import { localProviderBaseUrlFor, type EthagentConfig } from '../storage/config.js'
-import { formatModelDisplayName } from './modelDisplay.js'
-
-export type LlamaCppPreflightResult =
-  | { ok: true; alreadyRunning: boolean }
-  | {
-      ok: false
-      code: LlamaCppStartFailureCode
-      message: string
-      detail?: string
-      servedModels?: string[]
-    }
-
-export type LlamaCppPreflightDeps = {
-  fetchImpl?: typeof fetch
-  findLocalModel?: typeof findLocalHfModel
-  startServer?: typeof startLlamaCppServer
-  stopServer?: typeof stopLlamaCppServer
-  timeoutMs?: number
-}
-
-type ModelsProbe =
-  | { up: true; models: string[] }
-  | { up: false; models: [] }
-
-export async function ensureLlamaCppRunnerReady(
-  config: EthagentConfig,
-  deps: LlamaCppPreflightDeps = {},
-): Promise<LlamaCppPreflightResult> {
-  if (config.provider !== 'llamacpp') return { ok: true, alreadyRunning: true }
-
-  const baseUrl = localProviderBaseUrlFor('llamacpp', config.baseUrl)
-  const local = await (deps.findLocalModel ?? findLocalHfModel)(config.model)
-  if (!local || local.status !== 'ready') {
-    return {
-      ok: false,
-      code: 'model-file-missing',
-      message: formatPreflightFailure(
-        'local model is not imported',
-        config.model,
-        'choose an imported GGUF model from View Full Catalog or Add Local Model File',
-      ),
-    }
-  }
-
-  const probe = await probeLlamaCppModels(baseUrl, deps)
-  if (probe.up) {
-    if (probe.models.length > 0 && !probe.models.includes(config.model)) {
-      return {
-        ok: false,
-        code: 'different-model-running',
-        message: formatPreflightFailure(
-          'local runner is serving a different model',
-          config.model,
-          `a different local model is already running (${probe.models.join(', ')}); stop it before switching models`,
-        ),
-        servedModels: probe.models,
-      }
-    }
-    if (!local.mmprojPath) {
-      void fetchLlamaCppContextSize(llamaCppServerHostFromBaseUrl(baseUrl))
-      return { ok: true, alreadyRunning: true }
-    }
-    await (deps.stopServer ?? stopLlamaCppServer)().catch(() => null)
-  }
-
-  const result = await (deps.startServer ?? startLlamaCppServer)({
-    modelPath: local.localPath,
-    modelAlias: local.id,
-    host: llamaCppServerHostFromBaseUrl(baseUrl),
-    mmprojPath: local.mmprojPath,
-  })
-  if (result.ok) return { ok: true, alreadyRunning: result.alreadyRunning }
-  return withPreflightMessage(result, local)
-}
-
-export async function probeLlamaCppModels(
-  baseUrl: string,
-  deps: Pick<LlamaCppPreflightDeps, 'fetchImpl' | 'timeoutMs'> = {},
-): Promise<ModelsProbe> {
-  const controller = new AbortController()
-  const timer = setTimeout(() => controller.abort(), deps.timeoutMs ?? 800)
-  try {
-    const response = await (deps.fetchImpl ?? fetch)(llamaCppModelsEndpointForBaseUrl(baseUrl), {
-      signal: controller.signal,
-    })
-    if (!response.ok) return { up: false, models: [] }
-    const data = await response.json() as { data?: Array<{ id?: unknown }> }
-    return {
-      up: true,
-      models: (data.data ?? [])
-        .map(item => typeof item.id === 'string' ? item.id : '')
-        .filter(Boolean),
-    }
-  } catch {
-    return { up: false, models: [] }
-  } finally {
-    clearTimeout(timer)
-  }
-}
-
-export function llamaCppModelsEndpointForBaseUrl(baseUrl: string): string {
-  const url = new URL(baseUrl)
-  const path = stripTrailingSlash(url.pathname)
-  url.pathname = path.endsWith('/v1') ? `${path}/models` : `${path}/v1/models`
-  url.search = ''
-  url.hash = ''
-  return url.toString()
-}
-
-export function llamaCppServerHostFromBaseUrl(baseUrl: string): string {
-  const url = new URL(baseUrl)
-  const path = stripTrailingSlash(url.pathname)
-  url.pathname = path.endsWith('/v1') ? stripTrailingSlash(path.slice(0, -3)) || '/' : path || '/'
-  url.search = ''
-  url.hash = ''
-  return stripTrailingSlash(url.toString())
-}
-
-function withPreflightMessage(
-  result: Extract<LlamaCppStartResult, { ok: false }>,
-  local: LocalHfModel,
-): Extract<LlamaCppPreflightResult, { ok: false }> {
-  return {
-    ok: false,
-    code: result.code,
-    message: formatPreflightFailure(
-      'local runner is not reachable',
-      local.id,
-      result.message,
-      local.displayName,
-    ),
-    detail: result.detail,
-    servedModels: result.servedModels,
-  }
-}
-
-function formatPreflightFailure(
-  prefix: string,
-  modelId: string,
-  reason: string,
-  displayName?: string,
-): string {
-  const model = formatModelDisplayName('llamacpp', modelId, { displayName, maxLength: 64 })
-  return `${prefix}; failed to start ${model}: ${reason}`
-}
-
-function stripTrailingSlash(value: string): string {
-  return value.replace(/\/+$/, '')
-}

package/src/models/modelDisplay.ts

@@ -1,180 +0,0 @@
-export type ModelDisplayProvider = string
-
-type ModelDisplayOptions = {
-  maxLength?: number
-  displayName?: string
-}
-
-const DEFAULT_MODEL_DISPLAY_MAX = 64
-const HF_SEPARATOR = ' / '
-
-export function formatModelDisplayName(
-  provider: ModelDisplayProvider,
-  model: string,
-  options: ModelDisplayOptions = {},
-): string {
-  const maxLength = options.maxLength ?? DEFAULT_MODEL_DISPLAY_MAX
-  if (provider === 'llamacpp') {
-    return formatLocalHfModelDisplayName(model, {
-      maxLength,
-      displayName: options.displayName,
-    })
-  }
-  return truncateMiddle(model, maxLength)
-}
-
-export function formatLocalHfModelDisplayName(
-  modelId: string,
-  options: ModelDisplayOptions = {},
-): string {
-  const maxLength = options.maxLength ?? DEFAULT_MODEL_DISPLAY_MAX
-  const parsed = parseLocalHfModelId(modelId)
-  const label = options.displayName?.trim()
-  if (label) {
-    const parts = splitLocalHfDisplayName(label)
-    if (parts) return formatRepoAndFile(parts.repoId, parts.filename, maxLength)
-    if (parsed) return formatRepoAndFile(parsed.repoId, parsed.filename, maxLength)
-    return truncateMiddle(label, maxLength)
-  }
-
-  if (parsed) return formatRepoAndFile(parsed.repoId, parsed.filename, maxLength)
-  return truncateMiddle(modelId, maxLength)
-}
-
-export function truncateMiddle(value: string, maxLength: number): string {
-  if (maxLength <= 0) return ''
-  if (value.length <= maxLength) return value
-  if (maxLength <= 3) return value.slice(0, maxLength)
-  const remaining = maxLength - 3
-  const head = Math.ceil(remaining / 2)
-  const tail = Math.floor(remaining / 2)
-  return `${value.slice(0, head)}...${value.slice(value.length - tail)}`
-}
-
-function parseLocalHfModelId(modelId: string): { repoId: string; filename: string } | null {
-  const hash = modelId.indexOf('#')
-  if (hash <= 0 || hash === modelId.length - 1) return null
-  return {
-    repoId: modelId.slice(0, hash),
-    filename: modelId.slice(hash + 1),
-  }
-}
-
-function splitLocalHfDisplayName(label: string): { repoId: string; filename: string } | null {
-  const separator = label.indexOf(HF_SEPARATOR)
-  if (separator <= 0 || separator === label.length - HF_SEPARATOR.length) return null
-  return {
-    repoId: label.slice(0, separator),
-    filename: label.slice(separator + HF_SEPARATOR.length),
-  }
-}
-
-function formatRepoAndFile(repoId: string, filename: string, maxLength: number): string {
-  const file = friendlyFilename(filename)
-  const full = `${repoId}${HF_SEPARATOR}${file}`
-  if (full.length <= maxLength) return full
-
-  const compactFile = compactModelFilename(file, maxLength)
-  if (maxLength <= 32 || compactFile.length >= maxLength - HF_SEPARATOR.length - 6) {
-    return truncateEndClean(compactFile, maxLength)
-  }
-
-  const repoBudget = maxLength - HF_SEPARATOR.length - compactFile.length
-  const compactRepo = compactRepoId(repoId, repoBudget)
-  if (compactRepo) {
-    const compact = `${compactRepo}${HF_SEPARATOR}${compactFile}`
-    if (compact.length <= maxLength) return compact
-  }
-
-  const separatorBudget = HF_SEPARATOR.length
-  const partBudget = maxLength - separatorBudget
-  if (partBudget <= 8) return truncateMiddle(full, maxLength)
-
-  let repoMax = Math.min(repoId.length, Math.max(8, Math.floor(partBudget * 0.45)))
-  let fileMax = partBudget - repoMax
-
-  if (fileMax > file.length) {
-    repoMax = Math.min(repoId.length, repoMax + fileMax - file.length)
-    fileMax = file.length
-  }
-  if (repoMax > repoId.length) {
-    fileMax = Math.min(file.length, fileMax + repoMax - repoId.length)
-    repoMax = repoId.length
-  }
-  if (fileMax < 8 && partBudget >= 16) {
-    fileMax = 8
-    repoMax = partBudget - fileMax
-  }
-
-  return truncateMiddle(
-    `${truncateMiddle(repoId, repoMax)}${HF_SEPARATOR}${truncateMiddle(file, fileMax)}`,
-    maxLength,
-  )
-}
-
-function friendlyFilename(filename: string): string {
-  return filename.split('/').pop() ?? filename
-}
-
-function compactRepoId(repoId: string, maxLength: number): string {
-  if (maxLength <= 0) return ''
-  if (repoId.length <= maxLength) return repoId
-  const parts = repoId.split('/').filter(Boolean)
-  const owner = parts.length > 1 ? parts[0] ?? '' : ''
-  const repoName = parts.at(-1) ?? repoId
-  if (owner.length > 0) {
-    const nameBudget = maxLength - owner.length - 1
-    if (nameBudget >= 6) {
-      const compactName = compactModelCore(repoName, nameBudget)
-      const withOwner = `${owner}/${compactName}`
-      if (withOwner.length <= maxLength) return withOwner
-    }
-  }
-  return compactModelCore(repoName, maxLength)
-}
-
-function compactModelFilename(filename: string, maxLength: number): string {
-  const withoutExtension = filename.replace(/\.gguf$/i, '')
-  const compact = compactModelCore(withoutExtension, maxLength)
-  if (compact.length <= maxLength) return compact
-  return truncateEndClean(compact, maxLength)
-}
-
-function compactModelCore(value: string, maxLength: number): string {
-  if (maxLength <= 0) return ''
-  const cleaned = value
-    .replace(/\.gguf$/i, '')
-    .replace(/[_-]+/g, ' ')
-    .replace(/(^|[^0-9])\./g, '$1 ')
-    .replace(/\.(?=[^0-9]|$)/g, ' ')
-    .replace(/\bgguf\b/gi, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-  if (!cleaned) return truncateEndClean(value, maxLength)
-
-  const tokens = cleaned.split(' ')
-  const sizeIndex = tokens.findIndex(token => /^\d+(?:\.\d+)?[bm]$/i.test(token))
-  const familyTokens = sizeIndex > 0 ? tokens.slice(0, Math.min(sizeIndex, 3)) : tokens.slice(0, Math.min(tokens.length, 3))
-  const size = sizeIndex >= 0 ? tokens[sizeIndex] : undefined
-  const context = tokens.find(token => /^\d+k$/i.test(token))
-  const quant = quantizationLabel(value)
-  const parts = [familyTokens.join(' '), size, context, quant]
-    .filter((part): part is string => Boolean(part))
-    .filter((part, index, all) => all.findIndex(other => other.toLowerCase() === part.toLowerCase()) === index)
-  const compact = parts.join(' ').trim() || cleaned
-  if (compact.length <= maxLength) return compact
-  return truncateEndClean(compact, maxLength)
-}
-
-function quantizationLabel(value: string): string | undefined {
-  const match = value.match(/(?:^|[-_.\s])((?:Q\d(?:_[A-Za-z0-9]+)*)|BF16|F16|FP16)(?:$|[-_.\s])/i)
-  return match?.[1]?.toUpperCase()
-}
-
-function truncateEndClean(value: string, maxLength: number): string {
-  if (maxLength <= 0) return ''
-  if (value.length <= maxLength) return value
-  if (maxLength <= 3) return value.slice(0, maxLength)
-  const sliced = value.slice(0, maxLength - 3).replace(/[\s._/-]+$/g, '')
-  return `${sliced || value.slice(0, maxLength - 3)}...`
-}