ethagent 2.3.0 → 3.0.0

package/src/models/huggingface.ts

@@ -54,6 +54,12 @@ export type HfSafetyReview = {
   reasons: string[]
 }
 
+export type HfMmprojCandidate = {
+  filename: string
+  sizeBytes: number
+  localPath: string
+}
+
 export type HfDownloadPlan = {
   repo: HuggingFaceRepoInfo
   repoId: string
@@ -64,6 +70,8 @@ export type HfDownloadPlan = {
   localPath: string
   displayName: string
   review: HfSafetyReview
+  mmprojCandidate?: HfMmprojCandidate
+  includeMmproj?: boolean
 }
 
 export type LocalHfModel = {
@@ -90,6 +98,9 @@ export type LocalHfModel = {
   installedAt: string
   status: LocalHfStatus
   sha256?: string
+  mmprojPath?: string
+  mmprojAvailable?: boolean
+  mmprojSizeBytes?: number
 }
 
 export type HfDownloadProgress = {
@@ -291,6 +302,14 @@ export function ggufFiles(repo: HuggingFaceRepoInfo): HuggingFaceSibling[] {
     .sort((a, b) => a.filename.localeCompare(b.filename))
 }
 
+export function isMmprojFilename(filename: string): boolean {
+  return filename.toLowerCase().startsWith('mmproj-') && filename.toLowerCase().endsWith('.gguf')
+}
+
+export function findMmprojSibling(repo: HuggingFaceRepoInfo): HuggingFaceSibling | undefined {
+  return repo.siblings.find(file => isMmprojFilename(file.filename))
+}
+
 export async function createHfDownloadPlan(
   input: string,
   filename?: string,
@@ -320,6 +339,14 @@ export async function createHfDownloadPlan(
     requestedRevision,
     resolvedRevision,
   })
+  const mmprojSibling = findMmprojSibling(repo)
+  const mmprojCandidate: HfMmprojCandidate | undefined = mmprojSibling
+    ? {
+      filename: mmprojSibling.filename,
+      sizeBytes: mmprojSibling.sizeBytes ?? 0,
+      localPath: localPathFor(repo.repoId, resolvedRevision, mmprojSibling.filename),
+    }
+    : undefined
   return {
     repo,
     repoId: repo.repoId,
@@ -330,6 +357,7 @@ export async function createHfDownloadPlan(
     localPath: localPathFor(repo.repoId, resolvedRevision, selected.filename),
     displayName: displayNameFor(repo.repoId, selected.filename),
     review,
+    mmprojCandidate,
   }
 }
 
@@ -432,10 +460,151 @@ export async function* downloadHfModel(
   }
 
   await fs.rename(partialPath, plan.localPath)
-  await upsertLocalHfModel(modelFromPlan(plan, hash.digest('hex'), 'ready'))
+
+  let mmprojPath: string | undefined
+  if (plan.includeMmproj && plan.mmprojCandidate) {
+    yield* downloadMmprojFile(plan.repoId, plan.resolvedRevision, plan.mmprojCandidate, signal, fetchImpl)
+    mmprojPath = plan.mmprojCandidate.localPath
+  }
+
+  await upsertLocalHfModel(modelFromPlan(plan, hash.digest('hex'), 'ready', mmprojPath))
   yield { status: 'success', completed, total: Number.isFinite(total) ? total : completed }
 }
 
+async function* downloadMmprojFile(
+  repoId: string,
+  resolvedRevision: string,
+  candidate: HfMmprojCandidate,
+  signal: AbortSignal | undefined,
+  fetchImpl: FetchImpl,
+): AsyncIterable<HfDownloadProgress> {
+  await fs.mkdir(path.dirname(candidate.localPath), { recursive: true })
+  const partialPath = `${candidate.localPath}.partial`
+  const response = await fetchImpl(resolveUrl(repoId, resolvedRevision, candidate.filename), { signal })
+  if (!response.ok || !response.body) {
+    throw new Error(response.ok ? 'empty projector download body' : `projector download HTTP ${response.status}`)
+  }
+
+  const total = Number.parseInt(response.headers.get('content-length') ?? '', 10)
+  const handle = await fs.open(partialPath, 'w')
+  let completed = 0
+  let complete = false
+  let lastProgressAt = Date.now()
+  let lastProgressBytes = 0
+  yield { status: 'downloading-mmproj', completed, total: Number.isFinite(total) ? total : undefined }
+  try {
+    const reader = response.body.getReader()
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      if (signal?.aborted) throw new Error('Cancelled')
+      const buffer = Buffer.from(value)
+      await handle.write(buffer)
+      completed += buffer.byteLength
+      const now = Date.now()
+      if (shouldReportDownloadProgress(completed, lastProgressBytes, now, lastProgressAt)) {
+        lastProgressAt = now
+        lastProgressBytes = completed
+        yield { status: 'downloading-mmproj', completed, total: Number.isFinite(total) ? total : undefined }
+      }
+    }
+    complete = true
+  } finally {
+    await handle.close()
+    if (!complete) {
+      await fs.unlink(partialPath).catch(() => {})
+    }
+  }
+
+  await fs.rename(partialPath, candidate.localPath)
+}
+
+export async function backfillMmprojAvailability(
+  model: LocalHfModel,
+  fetchImpl: FetchImpl = fetch,
+): Promise<LocalHfModel> {
+  if (model.mmprojAvailable !== undefined) return model
+  try {
+    const repo = await fetchHuggingFaceRepoInfo({ repoId: model.repoId }, fetchImpl)
+    const sibling = findMmprojSibling(repo)
+    const next: LocalHfModel = {
+      ...model,
+      mmprojAvailable: Boolean(sibling),
+      mmprojSizeBytes: sibling?.sizeBytes,
+    }
+    await upsertLocalHfModel(next)
+    return next
+  } catch {
+    return model
+  }
+}
+
+export async function backfillMmprojForModels(
+  models: LocalHfModel[],
+  fetchImpl: FetchImpl = fetch,
+): Promise<LocalHfModel[]> {
+  const repoIdToProbe = new Map<string, Promise<HuggingFaceRepoInfo | null>>()
+  for (const model of models) {
+    if (model.mmprojAvailable !== undefined) continue
+    if (repoIdToProbe.has(model.repoId)) continue
+    repoIdToProbe.set(
+      model.repoId,
+      fetchHuggingFaceRepoInfo({ repoId: model.repoId }, fetchImpl).catch(() => null),
+    )
+  }
+  if (repoIdToProbe.size === 0) return models
+  const resolved = new Map<string, HuggingFaceRepoInfo | null>()
+  for (const [repoId, promise] of repoIdToProbe) {
+    resolved.set(repoId, await promise)
+  }
+  const out: LocalHfModel[] = []
+  for (const model of models) {
+    if (model.mmprojAvailable !== undefined) {
+      out.push(model)
+      continue
+    }
+    const repo = resolved.get(model.repoId)
+    if (!repo) {
+      out.push(model)
+      continue
+    }
+    const sibling = findMmprojSibling(repo)
+    const next: LocalHfModel = {
+      ...model,
+      mmprojAvailable: Boolean(sibling),
+      mmprojSizeBytes: sibling?.sizeBytes,
+    }
+    await upsertLocalHfModel(next)
+    out.push(next)
+  }
+  return out
+}
+
+export async function* addMmprojToInstalledModel(
+  modelId: string,
+  signal?: AbortSignal,
+  deps: { fetchImpl?: FetchImpl } = {},
+): AsyncIterable<HfDownloadProgress> {
+  const fetchImpl = deps.fetchImpl ?? fetch
+  const existing = await findLocalHfModel(modelId)
+  if (!existing) throw new Error(`model not installed: ${modelId}`)
+  if (existing.mmprojPath) {
+    yield { status: 'success', completed: 0 }
+    return
+  }
+  const repo = await fetchHuggingFaceRepoInfo({ repoId: existing.repoId }, fetchImpl)
+  const sibling = findMmprojSibling(repo)
+  if (!sibling) throw new Error(`no vision encoder available for ${existing.repoId}`)
+  const candidate: HfMmprojCandidate = {
+    filename: sibling.filename,
+    sizeBytes: sibling.sizeBytes ?? 0,
+    localPath: localPathFor(existing.repoId, existing.resolvedRevision, sibling.filename),
+  }
+  yield* downloadMmprojFile(existing.repoId, existing.resolvedRevision, candidate, signal, fetchImpl)
+  await upsertLocalHfModel({ ...existing, mmprojPath: candidate.localPath })
+  yield { status: 'success', completed: candidate.sizeBytes }
+}
+
 export function shouldReportDownloadProgress(
   completed: number,
   lastCompleted: number,
@@ -446,7 +615,13 @@ export function shouldReportDownloadProgress(
     || completed - lastCompleted >= DOWNLOAD_PROGRESS_MIN_BYTES
 }
 
-export function modelFromPlan(plan: HfDownloadPlan, sha256: string | undefined, status: LocalHfStatus): LocalHfModel {
+export function modelFromPlan(
+  plan: HfDownloadPlan,
+  sha256: string | undefined,
+  status: LocalHfStatus,
+  mmprojPath?: string,
+): LocalHfModel {
+  const mmprojAvailable = Boolean(plan.mmprojCandidate)
   const now = new Date().toISOString()
   return {
     id: localModelId(plan.repoId, plan.filename),
@@ -472,6 +647,9 @@ export function modelFromPlan(plan: HfDownloadPlan, sha256: string | undefined,
     installedAt: now,
     status,
     sha256,
+    mmprojPath,
+    mmprojAvailable,
+    mmprojSizeBytes: plan.mmprojCandidate?.sizeBytes,
   }
 }
 

package/src/models/llamacpp.ts

@@ -72,6 +72,9 @@ type LlamaCppStartDeps = {
   access?: typeof fs.access
   binaryPath?: string
   spawnImpl?: (command: string, args: readonly string[], options: NonNullable<Parameters<typeof spawn>[2]>) => ReturnType<typeof spawn>
+  killRogue?: (host: string) => Promise<KillRogueResult>
+  rogueDrainTimeoutMs?: number
+  rogueDrainPollMs?: number
 }
 
 export type LocalRunnerConfig = {
@@ -362,25 +365,51 @@ export async function startLlamaCppServer(args: {
   modelAlias: string
   host?: string
   ctxSize?: number
+  mmprojPath?: string
   readinessTimeoutMs?: number
   pollMs?: number
   deps?: LlamaCppStartDeps
 }): Promise<LlamaCppStartResult> {
   const host = args.host ?? DEFAULT_LLAMA_HOST
-  const initialStatus = await servedModelStatus(host, args.modelAlias)
-  if (initialStatus.state === 'ready') return { ok: true, alreadyRunning: true }
+  let initialStatus = await servedModelStatus(host, args.modelAlias)
+  if (initialStatus.state === 'ready' && args.mmprojPath) {
+    const pid = await readPidFile()
+    if (!pid) {
+      await (args.deps?.killRogue ?? killRogueLlamaProcesses)(host).catch(() => null)
+      const drained = await waitForHostDown(host, args.deps?.rogueDrainTimeoutMs ?? 6000, args.deps?.rogueDrainPollMs ?? 200)
+      if (!drained) {
+        return startFailure('different-model-running', {
+          servedModels: initialStatus.models,
+          detail: 'another process is holding the local model port and could not be stopped automatically',
+        })
+      }
+      initialStatus = await servedModelStatus(host, args.modelAlias)
+    }
+  }
+  if (initialStatus.state === 'ready') {
+    return { ok: true, alreadyRunning: true }
+  }
   if (initialStatus.state === 'different') {
     return startFailure('different-model-running', {
       servedModels: initialStatus.models,
     })
   }
 
+  const accessFn = args.deps?.access ?? fs.access
   try {
-    await (args.deps?.access ?? fs.access)(args.modelPath)
+    await accessFn(args.modelPath)
   } catch {
     return startFailure('model-file-missing', { detail: args.modelPath })
   }
 
+  if (args.mmprojPath) {
+    try {
+      await accessFn(args.mmprojPath)
+    } catch {
+      return startFailure('model-file-missing', { detail: args.mmprojPath })
+    }
+  }
+
   const binaryPath = args.deps?.binaryPath ?? (await findAndPersistLlamaCppServer()).path
   if (!binaryPath) {
     return startFailure('runner-not-installed')
@@ -390,21 +419,23 @@ export async function startLlamaCppServer(args: {
   const listenHost = url.hostname || '127.0.0.1'
   const port = url.port || (url.protocol === 'https:' ? '443' : '8080')
   const spawnImpl = args.deps?.spawnImpl ?? spawn
+  const spawnArgs: string[] = [
+    '-m',
+    args.modelPath,
+    '--host',
+    listenHost,
+    '--port',
+    port,
+    '--alias',
+    args.modelAlias,
+    '--ctx-size',
+    String(args.ctxSize ?? 32768),
+    '--jinja',
+  ]
+  if (args.mmprojPath) spawnArgs.push('--mmproj', args.mmprojPath)
   let child: ReturnType<typeof spawn>
   try {
-    child = spawnImpl(binaryPath, [
-      '-m',
-      args.modelPath,
-      '--host',
-      listenHost,
-      '--port',
-      port,
-      '--alias',
-      args.modelAlias,
-      '--ctx-size',
-      String(args.ctxSize ?? 32768),
-      '--jinja',
-    ], {
+    child = spawnImpl(binaryPath, spawnArgs, {
       detached: true,
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
@@ -424,6 +455,9 @@ export async function startLlamaCppServer(args: {
     })
   })
   child.unref()
+  if (typeof child.pid === 'number') {
+    await writePidFile(child.pid).catch(() => {})
+  }
 
   const ready = await waitForServedModel({
     host,
@@ -468,6 +502,84 @@ async function waitForServedModel(args: {
   return startFailure('readiness-timeout')
 }
 
+function pidFilePath(): string {
+  return path.join(getConfigDir(), 'llamacpp.pid')
+}
+
+async function writePidFile(pid: number): Promise<void> {
+  await ensureConfigDir()
+  await atomicWriteText(pidFilePath(), String(pid))
+}
+
+async function readPidFile(): Promise<number | null> {
+  try {
+    const raw = await fs.readFile(pidFilePath(), 'utf8')
+    const pid = Number.parseInt(raw.trim(), 10)
+    return Number.isInteger(pid) && pid > 0 ? pid : null
+  } catch {
+    return null
+  }
+}
+
+async function clearPidFile(): Promise<void> {
+  await fs.rm(pidFilePath(), { force: true }).catch(() => {})
+}
+
+export async function stopLlamaCppServer(args: {
+  host?: string
+  timeoutMs?: number
+  pollMs?: number
+  killImpl?: (pid: number, signal?: NodeJS.Signals | number) => void
+} = {}): Promise<
+  | { ok: true; stopped: boolean; reason?: 'untracked-server'; servedModels?: string[] }
+  | { ok: false; message: string }
+> {
+  const pid = await readPidFile()
+  if (!pid) {
+    const host = args.host ?? DEFAULT_LLAMA_HOST
+    const { up, models } = await fetchServedModels(host, 1500)
+    if (up && models.length > 0) {
+      return { ok: true, stopped: false, reason: 'untracked-server', servedModels: models }
+    }
+    return { ok: true, stopped: false }
+  }
+  const kill = args.killImpl ?? ((p, signal) => process.kill(p, signal))
+  try {
+    kill(pid, 'SIGTERM')
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ESRCH') {
+      await clearPidFile()
+      return { ok: true, stopped: false }
+    }
+    return { ok: false, message: (err as Error).message }
+  }
+  const host = args.host ?? DEFAULT_LLAMA_HOST
+  const deadline = Date.now() + (args.timeoutMs ?? 5000)
+  const pollMs = args.pollMs ?? 250
+  while (Date.now() < deadline) {
+    const status = await servedModelStatus(host, '__nothing__')
+    if (status.state === 'not-up' || status.models.length === 0) {
+      await clearPidFile()
+      return { ok: true, stopped: true }
+    }
+    await new Promise<void>(resolve => setTimeout(resolve, pollMs))
+  }
+  await clearPidFile()
+  return { ok: true, stopped: true }
+}
+
+async function waitForHostDown(host: string, timeoutMs: number, pollMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs
+  while (Date.now() < deadline) {
+    const { up } = await fetchServedModels(host, 800)
+    if (!up) return true
+    await new Promise<void>(resolve => setTimeout(resolve, pollMs))
+  }
+  const { up } = await fetchServedModels(host, 800)
+  return !up
+}
+
 async function servedModelStatus(host: string, modelAlias: string): Promise<
   | { state: 'not-up'; models: string[] }
   | { state: 'ready'; models: string[] }
@@ -479,6 +591,136 @@ async function servedModelStatus(host: string, modelAlias: string): Promise<
   return { state: 'different', models }
 }
 
+export type KillRogueResult = { killed: number; errors: string[] }
+
+export async function killRogueLlamaProcesses(host?: string): Promise<KillRogueResult> {
+  const result: KillRogueResult = { killed: 0, errors: [] }
+  try {
+    await stopLlamaCppServer({ timeoutMs: 1500 })
+  } catch (err: unknown) {
+    result.errors.push(`tracked stop failed: ${(err as Error).message}`)
+  }
+  const platform = os.platform()
+  const portOutcome = await killProcessOnPort(platform, host ?? DEFAULT_LLAMA_HOST)
+  result.killed += portOutcome.killed
+  if (portOutcome.error) result.errors.push(portOutcome.error)
+  const targets = platform === 'win32'
+    ? ['llama-server.exe', 'llama-cli.exe']
+    : ['llama-server', 'llama-cli']
+  for (const target of targets) {
+    const outcome = await runKillCommand(platform, target)
+    result.killed += outcome.killed
+    if (outcome.error) result.errors.push(outcome.error)
+  }
+  await clearPidFile()
+  return result
+}
+
+export async function killProcessOnPort(
+  platform: NodeJS.Platform,
+  host: string,
+): Promise<{ killed: number; error?: string }> {
+  const port = extractHostPort(host)
+  if (!port) return { killed: 0, error: 'no port to scan' }
+  const pids = await listListeningPids(platform, port)
+  if (pids.length === 0) return { killed: 0 }
+  let killed = 0
+  const errors: string[] = []
+  for (const pid of pids) {
+    const outcome = await killByPid(platform, pid)
+    if (outcome.killed) killed++
+    if (outcome.error) errors.push(outcome.error)
+  }
+  return errors.length > 0 ? { killed, error: errors.join('; ') } : { killed }
+}
+
+function extractHostPort(host: string): number | null {
+  try {
+    const url = new URL(host)
+    if (url.port) return Number.parseInt(url.port, 10)
+    return url.protocol === 'https:' ? 443 : 80
+  } catch {
+    return null
+  }
+}
+
+async function listListeningPids(platform: NodeJS.Platform, port: number): Promise<number[]> {
+  if (platform === 'win32') {
+    const result = await runCommand('netstat', ['-ano', '-p', 'tcp'], 4000)
+    if (!result) return []
+    return parseNetstatPids(result.stdout, port)
+  }
+  const result = await runCommand('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t'], 4000)
+  if (!result || result.code !== 0) return []
+  return result.stdout.split(/\r?\n/).map(line => Number.parseInt(line.trim(), 10)).filter(n => Number.isInteger(n) && n > 0)
+}
+
+export function parseNetstatPids(output: string, port: number): number[] {
+  const pids: number[] = []
+  const seen = new Set<number>()
+  const portSuffix = `:${port}`
+  for (const raw of output.split(/\r?\n/)) {
+    const line = raw.trim()
+    if (!line || !line.toUpperCase().includes('LISTENING')) continue
+    const cols = line.split(/\s+/)
+    if (cols.length < 5) continue
+    const local = cols[1] ?? ''
+    if (!local.endsWith(portSuffix)) continue
+    const pid = Number.parseInt(cols[cols.length - 1] ?? '', 10)
+    if (!Number.isInteger(pid) || pid <= 0) continue
+    if (pid === process.pid) continue
+    if (seen.has(pid)) continue
+    seen.add(pid)
+    pids.push(pid)
+  }
+  return pids
+}
+
+async function killByPid(platform: NodeJS.Platform, pid: number): Promise<{ killed: boolean; error?: string }> {
+  return new Promise(resolve => {
+    const cmd = platform === 'win32' ? 'taskkill' : 'kill'
+    const args = platform === 'win32' ? ['/F', '/T', '/PID', String(pid)] : ['-9', String(pid)]
+    const child = spawn(cmd, args, { stdio: 'ignore' })
+    child.on('error', err => resolve({ killed: false, error: `${cmd} ${pid}: ${err.message}` }))
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({ killed: true })
+        return
+      }
+      resolve({ killed: false, error: `${cmd} ${pid} exited ${code}` })
+    })
+  })
+}
+
+async function runKillCommand(
+  platform: NodeJS.Platform,
+  target: string,
+): Promise<{ killed: number; error?: string }> {
+  return new Promise(resolve => {
+    const cmd = platform === 'win32' ? 'taskkill' : 'pkill'
+    const args = platform === 'win32'
+      ? ['/F', '/T', '/IM', target]
+      : ['-f', target]
+    const child = spawn(cmd, args, { stdio: 'ignore' })
+    child.on('error', err => resolve({ killed: 0, error: `${cmd} ${target}: ${err.message}` }))
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({ killed: 1 })
+        return
+      }
+      if (platform === 'win32' && code === 128) {
+        resolve({ killed: 0 })
+        return
+      }
+      if (platform !== 'win32' && code === 1) {
+        resolve({ killed: 0 })
+        return
+      }
+      resolve({ killed: 0, error: `${cmd} ${target} exited ${code}` })
+    })
+  })
+}
+
 function startFailure(
   code: LlamaCppStartFailureCode,
   options: { detail?: string; servedModels?: string[] } = {},
@@ -500,7 +742,9 @@ function startFailureMessage(code: LlamaCppStartFailureCode, servedModels: strin
     case 'model-file-missing':
       return detail ? `model file not found: ${detail}` : 'model file was not found'
     case 'different-model-running':
-      return `a different local model is already running (${servedModels.join(', ')}); stop it before switching models`
+      return servedModels.length > 0
+        ? `a different local model is already running (${servedModels.join(', ')}); stop it before switching models`
+        : detail ?? 'a different local model is already running; stop it before switching models'
     case 'spawn-failed':
       return 'local runner could not be started'
     case 'runner-exited':

package/src/models/llamacppPreflight.ts

@@ -1,5 +1,6 @@
 import {
   startLlamaCppServer,
+  stopLlamaCppServer,
   type LlamaCppStartFailureCode,
   type LlamaCppStartResult,
 } from './llamacpp.js'
@@ -21,6 +22,7 @@ export type LlamaCppPreflightDeps = {
   fetchImpl?: typeof fetch
   findLocalModel?: typeof findLocalHfModel
   startServer?: typeof startLlamaCppServer
+  stopServer?: typeof stopLlamaCppServer
   timeoutMs?: number
 }
 
@@ -50,25 +52,27 @@ export async function ensureLlamaCppRunnerReady(
 
   const probe = await probeLlamaCppModels(baseUrl, deps)
   if (probe.up) {
-    if (probe.models.length === 0 || probe.models.includes(config.model)) {
-      return { ok: true, alreadyRunning: true }
-    }
-    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 (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) 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)