@agentic.artists/modelshortlist 0.2.1

package/.env.local.example

@@ -0,0 +1,6 @@
+# Required for local MCP use
+ARTIFICIAL_ANALYSIS_API_KEY=
+OPENROUTER_API_KEY=
+
+# Optional. Cache is in-process and best-effort.
+MODEL_SELECTOR_CACHE_TTL_MS=43200000

package/ATTRIBUTION.md

@@ -0,0 +1,25 @@
+# Attribution and upstream data
+
+ModelShortlist is open-source software. It does not bundle or redistribute the underlying datasets it queries.
+
+## Artificial Analysis
+
+ModelShortlist uses Artificial Analysis API data for model benchmarks, pricing, and performance information.
+
+Artificial Analysis: https://artificialanalysis.ai/
+
+Users supply their own Artificial Analysis API key and are responsible for complying with Artificial Analysis terms, plan limits, attribution requirements, and restrictions on external use or redistribution.
+
+## OpenRouter
+
+ModelShortlist uses OpenRouter's model catalog API for current model availability, capabilities, context limits, and pricing. It also uses OpenRouter's ZDR endpoint API to identify current Zero Data Retention options and endpoint-level provider/performance information when ZDR is relevant to the user's request.
+
+OpenRouter: https://openrouter.ai/
+
+Users supply their own OpenRouter API key and are responsible for complying with OpenRouter and applicable provider terms.
+
+## Project relationship
+
+ModelShortlist is not affiliated with, sponsored by, or endorsed by Artificial Analysis or OpenRouter.
+
+The MIT License applies only to the ModelShortlist source code. It does not grant rights to third-party data, APIs, trademarks, or services.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgenticArtists
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,240 @@
+# ModelShortlist
+
+[![CI](https://github.com/AgenticArtists/ModelShortlist/actions/workflows/ci.yml/badge.svg)](https://github.com/AgenticArtists/ModelShortlist/actions/workflows/ci.yml)
+
+**Stop guessing which AI model to use.**
+
+ModelShortlist is a local, bring-your-own-key MCP server that gives your AI assistant current model-selection context from the **full OpenRouter model catalog** plus **Artificial Analysis benchmarks**. Zero Data Retention (ZDR) is available as an optional hard constraint when you explicitly require it.
+
+No hosted service. No account. No deployment. Your API keys are supplied locally and used only to call the upstream services directly.
+
+Website: [modelshortlist.com](https://modelshortlist.com)
+
+## Why ModelShortlist
+
+Model choice is no longer just "which model has the highest benchmark score?" The right answer depends on the workload, capabilities, cost, context, and any privacy requirements you actually have.
+
+ModelShortlist helps your chat agent reason over:
+
+- the current OpenRouter model catalog
+- tool/function-calling support
+- context and completion limits
+- OpenRouter input/output pricing
+- current ZDR endpoint availability when privacy requires it
+- ZDR endpoint latency, throughput, uptime, and provider options when applicable
+- Artificial Analysis Intelligence Index
+- Artificial Analysis Coding Index
+- Artificial Analysis Agentic Index
+- Artificial Analysis pricing and median performance
+
+By default, **ZDR is not an eligibility requirement**. ModelShortlist considers the full OpenRouter catalog. If you explicitly require ZDR, the tool switches to current OpenRouter ZDR endpoint data and requires all hard constraints to be satisfied by the same real ZDR endpoint.
+
+The chat model makes the final recommendation based on your use case. ModelShortlist deliberately does not impose one universal ranking formula.
+
+## Quick start
+
+Requirements:
+
+- Node.js 20+
+- an Artificial Analysis API key
+- an OpenRouter API key
+- an MCP-capable chat client such as Hermes Desktop, Claude Code, Cursor, or VS Code/Copilot
+
+The npm package is:
+
+```text
+@agentic.artists/modelshortlist
+```
+
+### Fastest install: run from npm
+
+Most stdio MCP hosts can launch ModelShortlist directly with `npx`.
+
+```json
+{
+  "mcpServers": {
+    "modelshortlist": {
+      "command": "npx",
+      "args": ["-y", "@agentic.artists/modelshortlist"],
+      "env": {
+        "ARTIFICIAL_ANALYSIS_API_KEY": "YOUR_KEY",
+        "OPENROUTER_API_KEY": "YOUR_KEY"
+      }
+    }
+  }
+}
+```
+
+On Windows GUI clients where `npx` is not available on the app's PATH, use the full path to `npx.cmd` or use the local-clone setup below.
+
+### Local clone + gitignored `.env.local`
+
+This option keeps the API keys in a local gitignored file and generates client config with absolute Node/server paths.
+
+#### Windows
+
+```powershell
+git clone https://github.com/AgenticArtists/ModelShortlist.git
+cd ModelShortlist
+npm.cmd install
+npm.cmd run setup
+```
+
+#### macOS / Linux
+
+```bash
+git clone https://github.com/AgenticArtists/ModelShortlist.git
+cd ModelShortlist
+npm install
+npm run setup
+```
+
+The setup command:
+
+- asks for your two API keys with masked input
+- stores them only in the gitignored `.env.local`
+- prints ready-to-paste Hermes Desktop / Cursor and VS Code / Copilot MCP configs
+- uses the exact Node executable that ran setup, avoiding GUI-client PATH issues
+
+If PowerShell blocks `npm.ps1`, use `npm.cmd`; you do not need to change your execution policy.
+
+## Hermes Desktop
+
+Either use the npm config above or run the local setup command and paste the generated **Hermes Desktop / Cursor MCP config**.
+
+In Hermes Desktop, open **Skills & Tools → MCP**, import the JSON, and save it. Hermes should discover three tools:
+
+- `recommend_models`
+- `compare_models`
+- `modelshortlist_status`
+
+Then start a normal chat and ask something like:
+
+> I need the best-value model for a long-running autonomous coding agent. Tool calling is required and I need at least 100k context. Quality matters more than cost, but I care about value. What should I use?
+
+If privacy matters, say so explicitly:
+
+> Same workload, but ZDR is mandatory.
+
+More client setup examples and manual configuration are in [LOCAL_MCP.md](./LOCAL_MCP.md).
+
+## Example prompts
+
+> What's the cheapest model I'd trust with repetitive coding subagents? Tool use is required.
+
+> I need 200k context and tool use. What are my best current options?
+
+> I need 200k context, tool use, and ZDR. What are my best current options?
+
+> Is the premium frontier model actually worth the price for this coding workload?
+
+> Best model for extracting structured data from thousands of documents while keeping output cost low?
+
+> I need maximum autonomous coding performance under $10 per million output tokens. What should I use?
+
+## MCP tools
+
+### `recommend_models`
+
+The primary tool. It accepts a workload plus hard constraints such as:
+
+- ZDR required or not required
+- tool calling required
+- minimum context
+- maximum input/output price
+- creator/model filter
+
+When ZDR is not required, it considers the full OpenRouter catalog. When ZDR is explicitly required, it filters against current ZDR endpoints and verifies hard constraints against the same endpoint. Artificial Analysis benchmark data is attached only when the model can be confidently reconciled; models without a confident benchmark match remain eligible with missing benchmark fields rather than being silently removed.
+
+### `compare_models`
+
+Returns current OpenRouter catalog information, ZDR availability, and Artificial Analysis benchmark information when available for a specific shortlist of OpenRouter model IDs. ZDR is not assumed to be required.
+
+### `modelshortlist_status`
+
+Shows OpenRouter catalog coverage, ZDR coverage, model matching coverage, ambiguous/unmatched records, cache state, and Artificial Analysis rate-limit metadata.
+
+## How matching works
+
+The Artificial Analysis Free API does not expose an OpenRouter model ID. ModelShortlist therefore reconciles models conservatively:
+
+1. manually verified aliases
+2. exact normalized name matches
+3. otherwise the Artificial Analysis benchmark match remains unavailable
+
+ModelShortlist does **not** fuzzy-match uncertain model variants. A missing benchmark is better than attaching benchmark data to the wrong model. An unmatched OpenRouter model can still be considered; it simply carries no Artificial Analysis metrics.
+
+Verified aliases live in [`config/aliases.json`](./config/aliases.json).
+
+## ZDR is optional
+
+ModelShortlist tracks which models have current ZDR-capable OpenRouter endpoints, but it does **not** filter to them unless the user explicitly requires Zero Data Retention.
+
+When ZDR is required, ModelShortlist checks current endpoint-level eligibility and hard constraints. If you later call the selected model through OpenRouter, enforce ZDR again in the actual inference request:
+
+```json
+{
+  "provider": {
+    "zdr": true,
+    "require_parameters": true
+  }
+}
+```
+
+When ZDR is not required, do not add `provider.zdr=true` merely because a model happens to support it.
+
+## Data sources and attribution
+
+ModelShortlist uses data accessed with **your own API credentials**.
+
+- Model catalog, capabilities, pricing, context, and ZDR endpoint metadata: [OpenRouter](https://openrouter.ai/)
+- Benchmark and model-performance data: [Artificial Analysis](https://artificialanalysis.ai/)
+
+ModelShortlist is not affiliated with or endorsed by Artificial Analysis or OpenRouter.
+
+The ModelShortlist source code is licensed under the MIT License. Upstream data and APIs remain subject to their respective terms. In particular, Artificial Analysis API access may have restrictions on external use and redistribution. ModelShortlist does not bundle or host their dataset; each user accesses upstream data with their own credentials and is responsible for complying with the applicable terms.
+
+See [ATTRIBUTION.md](./ATTRIBUTION.md) for more detail.
+
+## Privacy and security
+
+- `.env.local` is gitignored for the clone-based setup.
+- API keys are loaded locally by the MCP process.
+- The setup command masks API-key input.
+- ModelShortlist does not operate a hosted backend.
+- MCP tools are read-only.
+- The server writes protocol traffic to stdout and diagnostic messages to stderr.
+- No telemetry is built into ModelShortlist.
+
+If you discover a security issue, see [SECURITY.md](./SECURITY.md).
+
+## Development
+
+Install dependencies and run validation:
+
+```powershell
+npm.cmd install
+npm.cmd test
+npm.cmd run check
+npm.cmd run pack:check
+```
+
+Test the MCP process manually:
+
+```powershell
+npm.cmd run mcp
+```
+
+A healthy server prints:
+
+```text
+ModelShortlist MCP server running on stdio
+```
+
+and waits for an MCP client. Press `Ctrl+C` to stop it.
+
+Contributions are welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/bin/modelshortlist.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../mcp/server.js'

package/config/aliases.json

@@ -0,0 +1,3 @@
+{
+  "_comment": "Map OpenRouter model_id -> Artificial Analysis slug. Add only manually verified exceptions. Exact normalized matching is attempted first."
+}

package/lib/artificial-analysis.js

@@ -0,0 +1,104 @@
+import { fetchJson } from './http.js'
+
+const AA_BASE_URL = 'https://artificialanalysis.ai/api/v2'
+
+function requireApiKey() {
+  const apiKey = process.env.ARTIFICIAL_ANALYSIS_API_KEY
+  if (!apiKey) {
+    throw new Error('ARTIFICIAL_ANALYSIS_API_KEY is not configured')
+  }
+  return apiKey
+}
+
+export async function fetchArtificialAnalysisModels() {
+  const apiKey = requireApiKey()
+  const models = []
+  let page = 1
+  let hasMore = true
+  let tier = null
+  let intelligenceIndexVersion = null
+  let rateLimit = null
+
+  while (hasMore) {
+    if (page > 20) {
+      throw new Error('Artificial Analysis pagination exceeded safety limit')
+    }
+
+    const url = new URL(`${AA_BASE_URL}/language/models/free`)
+    url.searchParams.set('page', String(page))
+
+    const { body, headers } = await fetchJson(url, {
+      headers: {
+        'x-api-key': apiKey,
+        accept: 'application/json',
+      },
+    })
+
+    if (!Array.isArray(body?.data)) {
+      throw new Error('Unexpected Artificial Analysis response: data is not an array')
+    }
+
+    models.push(...body.data)
+    tier = body.tier ?? headers.get('x-aa-tier') ?? tier
+    intelligenceIndexVersion =
+      body.intelligence_index_version ?? intelligenceIndexVersion
+    rateLimit = {
+      limit: numberOrNull(headers.get('x-ratelimit-limit')),
+      remaining: numberOrNull(headers.get('x-ratelimit-remaining')),
+      resetUnix: numberOrNull(headers.get('x-ratelimit-reset')),
+    }
+
+    hasMore = Boolean(body.pagination?.has_more)
+    page += 1
+  }
+
+  return {
+    models,
+    meta: {
+      tier,
+      pagesFetched: page - 1,
+      intelligenceIndexVersion,
+      rateLimit,
+    },
+  }
+}
+
+function numberOrNull(value) {
+  if (value == null || value === '') return null
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+export function compactArtificialAnalysisModel(model) {
+  return {
+    id: model.id ?? null,
+    slug: model.slug ?? null,
+    name: model.name ?? null,
+    creator: model.model_creator?.name ?? null,
+    release_date: model.release_date ?? null,
+    evaluations: {
+      intelligence_index:
+        model.evaluations?.artificial_analysis_intelligence_index ?? null,
+      coding_index:
+        model.evaluations?.artificial_analysis_coding_index ?? null,
+      agentic_index:
+        model.evaluations?.artificial_analysis_agentic_index ?? null,
+    },
+    pricing_usd_per_1m_tokens: {
+      input: model.pricing?.price_1m_input_tokens ?? null,
+      output: model.pricing?.price_1m_output_tokens ?? null,
+      cache_hit: model.pricing?.price_1m_cache_hit_tokens ?? null,
+      cache_write: model.pricing?.price_1m_cache_write_tokens ?? null,
+    },
+    performance: {
+      median_output_tokens_per_second:
+        model.performance?.median_output_tokens_per_second ?? null,
+      median_time_to_first_token_seconds:
+        model.performance?.median_time_to_first_token_seconds ?? null,
+      median_time_to_first_answer_token_seconds:
+        model.performance?.median_time_to_first_answer_token_seconds ?? null,
+      median_end_to_end_response_time_seconds:
+        model.performance?.median_end_to_end_response_time_seconds ?? null,
+    },
+  }
+}

package/lib/catalog.js

@@ -0,0 +1,117 @@
+import aliasesFile from '../config/aliases.json' with { type: 'json' }
+import {
+  compactArtificialAnalysisModel,
+  fetchArtificialAnalysisModels,
+} from './artificial-analysis.js'
+import {
+  buildOpenRouterCatalog,
+  fetchOpenRouterModels,
+  fetchOpenRouterZdrEndpoints,
+} from './openrouter.js'
+import { matchModels } from './match.js'
+
+const DEFAULT_TTL_MS = 12 * 60 * 60 * 1000
+let cached = null
+
+function aliases() {
+  return Object.fromEntries(
+    Object.entries(aliasesFile).filter(([key]) => !key.startsWith('_')),
+  )
+}
+
+export async function getMergedCatalog({ forceRefresh = false } = {}) {
+  const ttl = Number(process.env.MODEL_SELECTOR_CACHE_TTL_MS ?? DEFAULT_TTL_MS)
+  const now = Date.now()
+
+  if (
+    !forceRefresh &&
+    cached &&
+    Number.isFinite(ttl) &&
+    ttl > 0 &&
+    now - cached.cachedAt < ttl
+  ) {
+    return { ...cached.value, cache: { status: 'hit', ttl_ms: ttl } }
+  }
+
+  const [aaResult, openRouterRows, openRouterZdrEndpoints] = await Promise.all([
+    fetchArtificialAnalysisModels(),
+    fetchOpenRouterModels(),
+    fetchOpenRouterZdrEndpoints(),
+  ])
+
+  const openRouterModels = buildOpenRouterCatalog(openRouterRows, openRouterZdrEndpoints)
+  const aaModels = aaResult.models.map(compactArtificialAnalysisModel)
+  const reconciliation = matchModels(openRouterModels, aaModels, aliases())
+
+  const matchedById = new Map(
+    reconciliation.matches.map((entry) => [entry.openRouter.model_id, entry]),
+  )
+  const unmatchedById = new Map(
+    reconciliation.unmatched.map((entry) => [entry.openRouter.model_id, entry]),
+  )
+  const ambiguousById = new Map(
+    reconciliation.ambiguous.map((entry) => [entry.openRouter.model_id, entry]),
+  )
+
+  const models = openRouterModels.map((openRouter) => {
+    const matched = matchedById.get(openRouter.model_id)
+    if (matched) {
+      return {
+        ...openRouter,
+        artificial_analysis: matched.aa,
+        reconciliation: matched.match,
+      }
+    }
+
+    const ambiguous = ambiguousById.get(openRouter.model_id)
+    if (ambiguous) {
+      return {
+        ...openRouter,
+        artificial_analysis: null,
+        reconciliation: {
+          method: 'ambiguous',
+          confidence: 'none',
+          candidates: ambiguous.candidates,
+        },
+      }
+    }
+
+    return {
+      ...openRouter,
+      artificial_analysis: null,
+      reconciliation: {
+        method: 'unmatched',
+        confidence: 'none',
+        reason: unmatchedById.get(openRouter.model_id)?.reason ?? 'No Artificial Analysis match',
+      },
+    }
+  })
+
+  const value = {
+    generated_at: new Date().toISOString(),
+    models,
+    diagnostics: {
+      openrouter_model_count: openRouterModels.length,
+      openrouter_zdr_endpoint_count: openRouterZdrEndpoints.length,
+      openrouter_zdr_model_count: openRouterModels.filter((model) => model.zdr).length,
+      artificial_analysis_model_count: aaModels.length,
+      matched_model_count: reconciliation.matches.length,
+      unmatched_model_count: reconciliation.unmatched.length,
+      ambiguous_model_count: reconciliation.ambiguous.length,
+      aa: aaResult.meta,
+    },
+    unmatched: reconciliation.unmatched.map(({ openRouter, reason }) => ({
+      model_id: openRouter.model_id,
+      model_name: openRouter.model_name,
+      reason,
+    })),
+    ambiguous: reconciliation.ambiguous.map(({ openRouter, candidates }) => ({
+      model_id: openRouter.model_id,
+      model_name: openRouter.model_name,
+      candidates,
+    })),
+  }
+
+  cached = { cachedAt: now, value }
+  return { ...value, cache: { status: 'miss', ttl_ms: ttl } }
+}

package/lib/http.js

@@ -0,0 +1,68 @@
+const DEFAULT_TIMEOUT_MS = 15000
+const DEFAULT_ATTEMPTS = 3
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export async function fetchJson(url, options = {}) {
+  const {
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    attempts = DEFAULT_ATTEMPTS,
+    ...fetchOptions
+  } = options
+
+  let lastError
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), timeoutMs)
+
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        signal: controller.signal,
+      })
+
+      const text = await response.text()
+      let body = null
+      try {
+        body = text ? JSON.parse(text) : null
+      } catch {
+        body = { raw: text.slice(0, 1000) }
+      }
+
+      if (response.ok) {
+        return { body, headers: response.headers, status: response.status }
+      }
+
+      const retryable = response.status === 429 || response.status >= 500
+      const message =
+        body?.error ||
+        body?.message ||
+        `HTTP ${response.status} from ${new URL(url).hostname}`
+
+      const error = new Error(message)
+      error.status = response.status
+      error.responseBody = body
+      error.retryAfter = response.headers.get('retry-after')
+      lastError = error
+
+      if (!retryable || attempt === attempts) throw error
+
+      const retryAfterMs = Number(error.retryAfter) * 1000
+      const backoffMs = Number.isFinite(retryAfterMs) && retryAfterMs > 0
+        ? Math.min(retryAfterMs, 10000)
+        : 400 * (2 ** (attempt - 1))
+      await sleep(backoffMs)
+    } catch (error) {
+      lastError = error
+      if (attempt === attempts) throw error
+      if (error?.status && error.status < 500 && error.status !== 429) throw error
+      await sleep(400 * (2 ** (attempt - 1)))
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  throw lastError ?? new Error('Request failed')
+}

package/lib/match.js

@@ -0,0 +1,100 @@
+function ascii(value) {
+  return String(value ?? '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+}
+
+export function normalizeModelLabel(value) {
+  return ascii(value)
+    .replace(/&/g, ' and ')
+    .replace(/[^a-z0-9]+/g, '')
+}
+
+function normalizedVariantsForAa(model) {
+  return new Set(
+    [
+      model.name,
+      model.slug,
+      model.creator && model.name ? `${model.creator} ${model.name}` : null,
+    ]
+      .filter(Boolean)
+      .map(normalizeModelLabel)
+      .filter(Boolean),
+  )
+}
+
+function normalizedVariantsForOpenRouter(model) {
+  const slugPart = model.model_id?.includes('/')
+    ? model.model_id.slice(model.model_id.indexOf('/') + 1)
+    : model.model_id
+
+  return new Set(
+    [model.model_name, slugPart, model.model_id]
+      .filter(Boolean)
+      .map(normalizeModelLabel)
+      .filter(Boolean),
+  )
+}
+
+export function matchModels(openRouterModels, aaModels, aliases = {}) {
+  const aaBySlug = new Map(aaModels.map((m) => [m.slug, m]))
+  const aaVariants = aaModels.map((model) => ({
+    model,
+    variants: normalizedVariantsForAa(model),
+  }))
+
+  const matches = []
+  const unmatched = []
+  const ambiguous = []
+
+  for (const openRouter of openRouterModels) {
+    const aliasSlug = aliases[openRouter.model_id]
+    if (aliasSlug) {
+      const aa = aaBySlug.get(aliasSlug)
+      if (aa) {
+        matches.push({
+          openRouter,
+          aa,
+          match: { method: 'alias', confidence: 'verified' },
+        })
+        continue
+      }
+      unmatched.push({
+        openRouter,
+        reason: `Alias points to missing AA slug: ${aliasSlug}`,
+      })
+      continue
+    }
+
+    const orVariants = normalizedVariantsForOpenRouter(openRouter)
+    const candidates = aaVariants.filter(({ variants }) =>
+      [...orVariants].some((value) => variants.has(value)),
+    )
+
+    if (candidates.length === 1) {
+      matches.push({
+        openRouter,
+        aa: candidates[0].model,
+        match: { method: 'exact-normalized', confidence: 'high' },
+      })
+    } else if (candidates.length > 1) {
+      ambiguous.push({
+        openRouter,
+        candidates: candidates.map(({ model }) => ({
+          id: model.id,
+          slug: model.slug,
+          name: model.name,
+          creator: model.creator,
+        })),
+      })
+    } else {
+      unmatched.push({
+        openRouter,
+        reason: 'No exact normalized AA name/slug match',
+      })
+    }
+  }
+
+  return { matches, unmatched, ambiguous }
+}