ethagent 3.3.4 → 4.0.0

package/src/chat/messageMarkdown.ts

@@ -1,220 +0,0 @@
-export type MarkdownBlock =
-  | { kind: 'heading'; level: 1 | 2 | 3 | 4 | 5 | 6; text: string }
-  | { kind: 'paragraph'; text: string }
-  | { kind: 'quote'; lines: string[] }
-  | { kind: 'list'; ordered: boolean; items: string[] }
-  | { kind: 'code'; lang: string | null; code: string; open?: boolean }
-
-export type InlineToken =
-  | { kind: 'text'; text: string }
-  | { kind: 'bold'; text: string }
-  | { kind: 'italic'; text: string }
-  | { kind: 'code'; text: string }
-
-const UNREADABLE_REASONING_TEXT = 'reasoning output was not readable text'
-
-export function blockContentWidth(lines: string[]): number {
-  return Math.max(1, ...lines.map(displayWidth))
-}
-
-function displayWidth(line: string): number {
-  return (line || ' ').replace(/\t/g, '  ').length
-}
-
-export function parseMarkdownBlocks(markdown: string): MarkdownBlock[] {
-  const text = markdown.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
-  if (!text.trim()) return []
-
-  const blocks: MarkdownBlock[] = []
-  const lines = text.split('\n')
-  let index = 0
-
-  while (index < lines.length) {
-    const line = lines[index] ?? ''
-    const trimmed = line.trim()
-
-    if (!trimmed) {
-      index += 1
-      continue
-    }
-
-    const fence = trimmed.match(/^```([\w+-]*)\s*$/)
-    if (fence) {
-      const lang = fence[1] && fence[1].length > 0 ? fence[1] : null
-      index += 1
-      const body: string[] = []
-      let closed = false
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (nextLine.trim().match(/^```\s*$/)) {
-          closed = true
-          index += 1
-          break
-        }
-        body.push(nextLine)
-        index += 1
-      }
-      blocks.push({ kind: 'code', lang, code: body.join('\n'), open: !closed })
-      continue
-    }
-
-    const heading = line.match(/^(#{1,6})\s+(.*)$/)
-    if (heading) {
-      const [, hashes = '#', headingText = ''] = heading
-      blocks.push({
-        kind: 'heading',
-        level: hashes.length as 1 | 2 | 3 | 4 | 5 | 6,
-        text: headingText.trim(),
-      })
-      index += 1
-      continue
-    }
-
-    if (/^>\s?/.test(trimmed)) {
-      const quoteLines: string[] = []
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        if (!/^>\s?/.test(nextLine.trim())) break
-        quoteLines.push(nextLine.trim().replace(/^>\s?/, ''))
-        index += 1
-      }
-      blocks.push({ kind: 'quote', lines: quoteLines })
-      continue
-    }
-
-    const ordered = trimmed.match(/^\d+\.\s+(.*)$/)
-    const unordered = trimmed.match(/^[-*+]\s+(.*)$/)
-    if (ordered || unordered) {
-      const items: string[] = []
-      const orderedList = Boolean(ordered)
-      while (index < lines.length) {
-        const nextLine = lines[index] ?? ''
-        const match = orderedList
-          ? nextLine.trim().match(/^\d+\.\s+(.*)$/)
-          : nextLine.trim().match(/^[-*+]\s+(.*)$/)
-        if (!match) break
-        items.push(match[1] ?? '')
-        index += 1
-      }
-      blocks.push({ kind: 'list', ordered: orderedList, items })
-      continue
-    }
-
-    const paragraph: string[] = []
-    while (index < lines.length) {
-      const nextLine = lines[index] ?? ''
-      const nextTrimmed = nextLine.trim()
-      if (!nextTrimmed) break
-      if (nextTrimmed.match(/^```([\w+-]*)\s*$/)) break
-      if (nextLine.match(/^(#{1,6})\s+(.*)$/)) break
-      if (/^>\s?/.test(nextTrimmed)) break
-      if (nextTrimmed.match(/^\d+\.\s+(.*)$/) || nextTrimmed.match(/^[-*+]\s+(.*)$/)) break
-      paragraph.push(nextLine)
-      index += 1
-    }
-    blocks.push({ kind: 'paragraph', text: paragraph.join('\n').trim() })
-  }
-
-  return blocks
-}
-
-export function parseInlineTokens(text: string): InlineToken[] {
-  const tokens: InlineToken[] = []
-  const source = normalizeInlineDisplayText(text)
-  const pattern = /(`[^`\n]+`|\*\*[^*\n]+?\*\*|__[^_\n]+?__|\*[^*\n]+?\*|_[^_\n]+?_)/g
-  let lastIndex = 0
-  let match: RegExpExecArray | null
-
-  while ((match = pattern.exec(source)) !== null) {
-    if (match.index > lastIndex) {
-      tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex, match.index)) })
-    }
-
-    const token = match[0]
-    if ((token.startsWith('**') && token.endsWith('**')) || (token.startsWith('__') && token.endsWith('__'))) {
-      tokens.push({ kind: 'bold', text: cleanPlainInlineText(token.slice(2, -2)) })
-    } else if ((token.startsWith('*') && token.endsWith('*')) || (token.startsWith('_') && token.endsWith('_'))) {
-      tokens.push({ kind: 'italic', text: cleanPlainInlineText(token.slice(1, -1)) })
-    } else if (token.startsWith('`') && token.endsWith('`')) {
-      tokens.push({ kind: 'code', text: token.slice(1, -1) })
-    }
-
-    lastIndex = match.index + token.length
-  }
-
-  if (lastIndex < source.length || tokens.length === 0) {
-    tokens.push({ kind: 'text', text: cleanPlainInlineText(source.slice(lastIndex)) })
-  }
-
-  return tokens.filter(token => token.text.length > 0)
-}
-
-function normalizeInlineDisplayText(text: string): string {
-  return text
-    .replace(/\\\(/g, '')
-    .replace(/\\\)/g, '')
-    .replace(/\\\[/g, '')
-    .replace(/\\\]/g, '')
-    .replace(/\$\$([^$]+)\$\$/g, '$1')
-    .replace(/\$([^$\n]+)\$/g, '$1')
-    .replace(/\\([{}[\]()])/g, '$1')
-    .replace(/\/([{}])/g, '$1')
-}
-
-function cleanPlainInlineText(text: string): string {
-  return text.replace(/\*+/g, '')
-}
-
-export function summarizeThinking(text: string): string {
-  const sample = text.length > 1000 ? text.slice(-1000) : text
-  const normalized = sample.replace(/\s+/g, ' ').trim()
-  if (!normalized) return ''
-  const prefix = text.length > sample.length ? '...' : ''
-  if (normalized.length + prefix.length <= 120) return `${prefix}${normalized}`
-  return `${prefix}${normalized.slice(Math.max(0, normalized.length - (120 - prefix.length)))}`
-}
-
-export function clipTextForDisplay(text: string, maxChars: number): { text: string; omittedChars: number } {
-  if (text.length <= maxChars) return { text, omittedChars: 0 }
-  const rawStart = Math.max(0, text.length - maxChars)
-  const newline = text.indexOf('\n', rawStart)
-  const start = newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
-  return {
-    text: text.slice(start),
-    omittedChars: start,
-  }
-}
-
-export function sanitizeReasoningForDisplay(text: string): string {
-  const normalized = text
-    .replace(/\r\n/g, '\n')
-    .replace(/\r/g, '\n')
-    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '')
-  const controlCount = countMatches(normalized, /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g)
-  const cleaned = normalized
-    .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\uFFFD]/g, '')
-    .replace(/\t/g, '  ')
-  const visibleLength = cleaned.replace(/\s/g, '').length
-  if (visibleLength === 0) return ''
-  if (controlCount > 0 && controlCount / Math.max(1, text.length) > 0.05) return UNREADABLE_REASONING_TEXT
-  if (looksLikeUnreadableReasoning(cleaned)) return UNREADABLE_REASONING_TEXT
-  return cleaned
-}
-
-function looksLikeUnreadableReasoning(text: string): boolean {
-  const visible = text.replace(/\s/g, '')
-  if (visible.length < 120) return false
-  const letters = countMatches(visible, /[A-Za-z]/g)
-  const digits = countMatches(visible, /\d/g)
-  const words = text.match(/[A-Za-z]{3,}/g) ?? []
-  const wordChars = words.reduce((sum, word) => sum + word.length, 0)
-  const whitespace = countMatches(text, /\s/g)
-  const symbolDensity = (visible.length - letters - digits) / visible.length
-  const wordDensity = wordChars / visible.length
-  const whitespaceDensity = whitespace / Math.max(1, text.length)
-  return symbolDensity > 0.38 && wordDensity < 0.32 && whitespaceDensity < 0.12
-}
-
-function countMatches(text: string, pattern: RegExp): number {
-  return text.match(pattern)?.length ?? 0
-}

package/src/chat/messageRows.ts

@@ -1,43 +0,0 @@
-import type { RowSlice } from './transcript/transcriptViewport.js'
-import type { MessageRow } from './MessageList.js'
-
-export function rowsToFullSlices(rows: MessageRow[]): Array<RowSlice<MessageRow>> {
-  return rows.map(row => ({ row, clipStart: 0, clipEnd: Number.MAX_SAFE_INTEGER, rowHeight: Number.MAX_SAFE_INTEGER }))
-}
-
-export function toggleLatestReasoningRow(rows: MessageRow[]): MessageRow[] {
-  return toggleInspectableRow(rows)
-}
-
-export function toggleReasoningRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  return toggleInspectableRow(rows, rowId)
-}
-
-export function toggleInspectableRow(rows: MessageRow[], rowId?: string): MessageRow[] {
-  let index = -1
-  if (rowId) {
-    index = rows.findIndex(row => row.id === rowId && isInspectableRole(row.role))
-  }
-  if (index === -1) {
-    for (let cursor = rows.length - 1; cursor >= 0; cursor -= 1) {
-      const role = rows[cursor]?.role
-      if (role && isInspectableRole(role)) {
-        index = cursor
-        break
-      }
-    }
-  }
-  if (index === -1) return rows
-  const row = rows[index]
-  if (!row) return rows
-  if (row.role === 'thinking') {
-    const next = rows.slice()
-    next[index] = { ...row, expanded: !row.expanded }
-    return next
-  }
-  return rows
-}
-
-function isInspectableRole(role: MessageRow['role']): boolean {
-  return role === 'thinking'
-}

package/src/chat/planImplementation.ts

@@ -1,62 +0,0 @@
-import type { SessionMessage } from '../storage/sessions.js'
-
-const MAX_HANDOFF_SUMMARY_CHARS = 12_000
-
-export function chatFooterShortcutText(_canScrollTranscript: boolean): string {
-  return 'alt+p model · alt+i identity'
-}
-
-export function buildPlanImplementationPrompt(plan: string): string {
-  return [
-    'Implement the approved plan below.',
-    '',
-    'Use native ethagent tools directly. Do not translate tool names into shell commands.',
-    'For workspace inspection, call list_directory and read_file directly.',
-    'For file creation or edits, call edit_file directly.',
-    'Use run_bash only for an actual shell command that cannot be performed by a narrower native tool, such as starting a local server after files exist.',
-    'Ignore any plan wording that says to execute file work as a Bash script or directly in the terminal; the native tools above are authoritative.',
-    'Read the relevant files before editing, make the required changes, and verify the result when possible.',
-    '',
-    plan,
-  ].join('\n')
-}
-
-export function buildPlanTransferSeedMessages(args: {
-  sourceSessionId: string
-  summary: string
-  plan: string
-  createdAt: string
-}): SessionMessage[] {
-  return [
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        `Planning handoff from ${args.sourceSessionId.slice(0, 8)}:`,
-        '',
-        args.summary.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-    {
-      role: 'user',
-      synthetic: true,
-      content: [
-        'Approved plan to implement:',
-        '',
-        args.plan.trim(),
-      ].join('\n'),
-      createdAt: args.createdAt,
-    },
-  ]
-}
-
-export function normalizeHandoffSummary(summary: string): string {
-  const trimmed = summary.trim()
-  if (trimmed.length <= MAX_HANDOFF_SUMMARY_CHARS) return trimmed
-  return [
-    trimmed.slice(0, MAX_HANDOFF_SUMMARY_CHARS - 96).trimEnd(),
-    '',
-    '[handoff truncated to keep the resumed conversation responsive]',
-  ].join('\n')
-}

package/src/chat/slashCommandHandlers.ts

@@ -1,122 +0,0 @@
-import { clearIdentity, getIdentityStatus } from '../storage/identity.js'
-import type { SlashContext, SlashResult } from './commands.js'
-
-export async function runMcp(args: string, ctx: SlashContext): Promise<SlashResult> {
-  if (!ctx.mcp) {
-    return { kind: 'note', variant: 'error', text: 'MCP runtime is not available in this session.' }
-  }
-
-  const tokens = args.trim().split(/\s+/).filter(Boolean)
-  const sub = tokens[0]?.toLowerCase() ?? ''
-  if (!sub || sub === 'status' || sub === 'list') {
-    return { kind: 'note', text: ctx.mcp.renderStatus(), variant: 'info' }
-  }
-
-  try {
-    if (sub === 'approve') {
-      const name = tokens.slice(1).join(' ')
-      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp approve <server>' }
-      return { kind: 'note', text: await ctx.mcp.approveServer(name), variant: 'dim' }
-    }
-    if (sub === 'reject') {
-      const name = tokens.slice(1).join(' ')
-      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp reject <server>' }
-      return { kind: 'note', text: await ctx.mcp.rejectServer(name), variant: 'dim' }
-    }
-    if (sub === 'reconnect') {
-      const name = tokens.slice(1).join(' ') || undefined
-      return { kind: 'note', text: await ctx.mcp.reconnect(name), variant: 'dim' }
-    }
-    if (sub === 'enable' || sub === 'disable') {
-      const name = tokens.slice(1).join(' ')
-      if (!name) return { kind: 'note', variant: 'error', text: `usage: /mcp ${sub} <server>` }
-      return { kind: 'note', text: await ctx.mcp.setEnabled(name, sub === 'enable'), variant: 'dim' }
-    }
-    if (sub === 'add-json') {
-      const project = tokens[1] === '--project'
-      const nameIndex = project ? 2 : 1
-      const name = tokens[nameIndex]
-      if (!name) return { kind: 'note', variant: 'error', text: 'usage: /mcp add-json [--project] <name> <json>' }
-      const jsonStart = nthTokenStart(args, nameIndex + 1)
-      const json = jsonStart >= 0 ? args.slice(jsonStart).trim() : ''
-      if (!json) return { kind: 'note', variant: 'error', text: 'usage: /mcp add-json [--project] <name> <json>' }
-      return { kind: 'note', text: await ctx.mcp.addJson(name, json, project ? 'project' : 'user'), variant: 'dim' }
-    }
-  } catch (err: unknown) {
-    return { kind: 'note', variant: 'error', text: `MCP failed: ${(err as Error).message}` }
-  }
-
-  return {
-    kind: 'note',
-    variant: 'error',
-    text: 'usage: /mcp [status|approve <server>|reject <server>|reconnect [server]|enable <server>|disable <server>|add-json [--project] <name> <json>]',
-  }
-}
-
-export async function runIdentity(args: string, ctx: SlashContext): Promise<SlashResult> {
-  const tokens = args.trim().split(/\s+/).filter(Boolean)
-  const sub = tokens[0]?.toLowerCase() ?? ''
-  const rest = tokens.slice(1)
-
-  if (!sub) {
-    ctx.onIdentityRequest('manage')
-    return { kind: 'handled' }
-  }
-
-  if (sub === 'status') {
-    const status = await getIdentityStatus(ctx.config)
-    if (!status) {
-      return {
-        kind: 'note',
-        variant: 'dim',
-        text: 'No Ethereum identity set. Run /identity create to make one.',
-      }
-    }
-    const lines = [
-      `address    ${status.address}`,
-      `updated    ${status.createdAt}`,
-      `wallet     ${status.backend}`,
-    ]
-    if (status.source) lines.push(`registry   ${status.source}`)
-    if (status.agentId) lines.push(`agent      #${status.agentId}`)
-    return { kind: 'note', text: lines.join('\n') }
-  }
-
-  if (sub === 'create') {
-    ctx.onIdentityRequest('create')
-    return { kind: 'handled' }
-  }
-
-  if (sub === 'load') {
-    ctx.onIdentityRequest('load')
-    return { kind: 'handled' }
-  }
-
-  if (sub === 'remove') {
-    if (rest[0] !== 'confirm') {
-      return {
-        kind: 'note',
-        variant: 'error',
-        text: 'Remove deletes local identity metadata and any legacy stored key. Re-run with: /identity remove confirm',
-      }
-    }
-    const status = await getIdentityStatus(ctx.config)
-    if (!status) {
-      return { kind: 'note', variant: 'dim', text: 'No Ethereum identity to remove.' }
-    }
-    const next = await clearIdentity(ctx.config)
-    ctx.onReplaceConfig(next)
-    return { kind: 'note', text: `Removed identity ${status.address}.`, variant: 'dim' }
-  }
-
-  return {
-    kind: 'note',
-    variant: 'error',
-    text: 'usage: /identity [status|create|load|remove confirm]',
-  }
-}
-
-function nthTokenStart(value: string, tokenIndex: number): number {
-  const matches = [...value.matchAll(/\S+/g)]
-  return matches[tokenIndex]?.index ?? -1
-}

package/src/chat/slashCommandViews.ts

@@ -1,120 +0,0 @@
-import type { EthagentConfig, ProviderId } from '../storage/config.js'
-import { getConfigPath, localProviderBaseUrlFor } from '../storage/config.js'
-import { detectLlamaCpp } from '../models/llamacpp.js'
-import { detectSpec } from '../models/runtimeDetection.js'
-import { getIdentityStatus } from '../storage/identity.js'
-import { getLocalHfCacheDir } from '../models/huggingface.js'
-import { formatModelDisplayName } from '../models/modelDisplay.js'
-import { providerDisplayName } from '../models/modelPickerOptions.js'
-import type { ModelCatalogResult } from '../models/catalog.js'
-import type { SlashContext } from './commands.js'
-
-export function renderStatus(ctx: SlashContext): string {
-  const elapsedMs = Date.now() - ctx.startedAt
-  const minutes = Math.floor(elapsedMs / 60000)
-  const seconds = Math.floor((elapsedMs % 60000) / 1000)
-  const elapsed = minutes > 0 ? `${minutes}m${seconds.toString().padStart(2, '0')}s` : `${seconds}s`
-  const displayModel = formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })
-  return [
-    `provider   ${providerDisplayName(ctx.config.provider)}`,
-    `model      ${displayModel}`,
-    `cwd        ${ctx.cwd}`,
-    `session    ${ctx.sessionId.slice(0, 8)}`,
-    'state      active',
-    `turns      ${ctx.turns}`,
-    `tokens     ~${ctx.approxTokens}`,
-    `context    ${ctx.contextUsage.percent}% (~${ctx.contextUsage.usedTokens}/${ctx.contextUsage.windowTokens}, ${ctx.contextUsage.source})`,
-    `elapsed    ${elapsed}`,
-  ].join('\n')
-}
-
-export function renderContext(ctx: SlashContext): string {
-  const usage = ctx.contextUsage
-  const free = Math.max(0, usage.windowTokens - usage.usedTokens)
-  const action =
-    usage.percent >= 90
-      ? 'Context is near the model limit. New requests will ask you to summarize into a new conversation, switch models, ignore and send, or cancel.'
-      : usage.percent >= 75
-        ? 'Context is getting full. Consider /compact before a new task boundary.'
-        : 'Context has comfortable room.'
-  return [
-    'context usage:',
-    `  model      ${providerDisplayName(ctx.config.provider)} · ${formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })}`,
-    `  used       ~${usage.usedTokens} / ${usage.windowTokens} tokens (${usage.percent}%)`,
-    `  free       ~${free} tokens`,
-    `  estimate   ${usage.confidence} (${usage.source})`,
-    '  session    active',
-    '',
-    action,
-  ].join('\n')
-}
-
-export function renderDoctor(
-  spec: Awaited<ReturnType<typeof detectSpec>>,
-  keys: ReadonlyArray<readonly [ProviderId, boolean]>,
-  identity: Awaited<ReturnType<typeof getIdentityStatus>>,
-  ctx: SlashContext,
-  llamaCpp: Awaited<ReturnType<typeof detectLlamaCpp>>,
-  hfModelCount: number,
-): string {
-  const lines: string[] = ['diagnostics:']
-  lines.push(`  platform   ${spec.platform}/${spec.arch}${spec.isAppleSilicon ? ' (apple silicon)' : ''}`)
-  lines.push(`  ram        ${formatGB(spec.effectiveRamBytes)}${spec.gpuVramBytes ? ` · vram ${formatGB(spec.gpuVramBytes)}` : ''}`)
-  lines.push(`  local run  ${llamaCpp.binaryPresent ? 'installed' : 'not installed'} · server ${llamaCpp.serverUp ? 'up' : 'down'}`)
-  lines.push(`  hf models  ${hfModelCount} downloaded`)
-  lines.push('')
-  lines.push('config:')
-  lines.push(`  provider   ${providerDisplayName(ctx.config.provider)}`)
-  lines.push(`  model      ${formatModelDisplayName(ctx.config.provider, ctx.config.model, { maxLength: 72 })}`)
-  if (ctx.config.baseUrl) lines.push(`  baseUrl    ${ctx.config.baseUrl}`)
-  if (ctx.config.provider === 'llamacpp') lines.push(`  hf cache   ${getLocalHfCacheDir()}`)
-  lines.push(`  path       ${getConfigPath()}`)
-  lines.push('')
-  lines.push('keys:')
-  for (const [provider, present] of keys) {
-    lines.push(`  ${providerDisplayName(provider).padEnd(9)}  ${present ? 'set' : 'not set'}`)
-  }
-  lines.push('')
-  lines.push('identity:')
-  if (identity) {
-    lines.push(`  address    ${identity.address}`)
-    lines.push(`  backend    ${identity.backend}`)
-    if (identity.source) lines.push(`  source     ${identity.source}`)
-    if (identity.agentId) lines.push(`  token      #${identity.agentId}`)
-  } else {
-    lines.push('  address    not set')
-  }
-  return lines.join('\n')
-}
-
-export function renderModelCatalog(catalog: ModelCatalogResult, currentModel: string): string {
-  const title = catalog.status === 'fallback'
-    ? `${providerDisplayName(catalog.provider)} models (fallback${catalog.error ? `: ${catalog.error}` : ''}):`
-    : `${providerDisplayName(catalog.provider)} models:`
-  const lines = catalog.entries.map(entry => {
-    const marker = entry.id === currentModel ? '*' : ' '
-    const suffix = entry.source === 'fallback' ? '  fallback' : ''
-    return `${marker} ${formatModelDisplayName(catalog.provider, entry.id, { maxLength: 72 })}${suffix}`
-  })
-  return [title, ...lines].join('\n')
-}
-
-export function baseUrlForModelSwitch(config: EthagentConfig): string | undefined {
-  if (config.provider === 'llamacpp') return localProviderBaseUrlFor('llamacpp', config.baseUrl)
-  if (config.provider === 'openai') return config.baseUrl
-  return undefined
-}
-
-export function formatBytes(bytes: number): string {
-  if (bytes <= 0) return '—'
-  const gb = bytes / (1024 * 1024 * 1024)
-  if (gb >= 1) return `${gb.toFixed(1)}GB`
-  const mb = bytes / (1024 * 1024)
-  return `${mb.toFixed(0)}MB`
-}
-
-function formatGB(bytes: number): string {
-  const gb = bytes / (1024 * 1024 * 1024)
-  if (gb >= 10) return `${Math.round(gb)}GB`
-  return `${gb.toFixed(1)}GB`
-}