@javierkaiser/opencode-indexing 0.1.1 → 0.2.0

package/src/registry.ts

@@ -4,42 +4,71 @@ import { createHash } from "node:crypto"
  * Embedding model catalog, mirrored from Kilo Code / Roo Code
  * (`packages/kilo-indexing/src/indexing/model-registry.ts`) so that query
  * embeddings are compatible with existing Kilo indexes.
+ *
+ * The mirror is the compatibility contract: an import is accepted only when
+ * provider, model id and dimension match byte for byte, so an entry here that
+ * drifts from Kilo's silently makes an index un-importable. Entries marked
+ * `kiloMirror: false` are ours alone and can never be imported.
  */
 
 import type { EmbedderProvider, ModelProfile } from "./types.ts"
 
+/** Input ceilings and batch limits are from each provider's own documentation. */
 const profiles: Partial<Record<EmbedderProvider, Record<string, ModelProfile>>> = {
   openai: {
-    "text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4 },
-    "text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4 },
-    "text-embedding-ada-002": { dimension: 1536, scoreThreshold: 0.4 },
+    "text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
+    "text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
+    "text-embedding-ada-002": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
   },
   ollama: {
-    "nomic-embed-text": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: " },
-    "nomic-embed-text:latest": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: " },
-    "mxbai-embed-large": { dimension: 1024, scoreThreshold: 0.3 },
-    "all-minilm": { dimension: 384, scoreThreshold: 0.3 },
+    // 512 tokens is the smallest input in the catalog by a wide margin. A chunk of
+    // real code is routinely longer, and Ollama truncates by default, so this one
+    // is also the reason the Ollama adapter refuses to truncate silently.
+    "mxbai-embed-large": { dimension: 1024, scoreThreshold: 0.3, maxInputTokens: 512, normalized: true },
+    "nomic-embed-text": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: ", maxInputTokens: 2048, normalized: true },
+    // Ollama reports the tag, but Kilo stores whatever its config names, so an
+    // index carrying this id was written by us and cannot be imported.
+    "nomic-embed-text:latest": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: ", maxInputTokens: 2048, normalized: true, kiloMirror: false },
+    "all-minilm": { dimension: 384, scoreThreshold: 0.3, maxInputTokens: 512, normalized: true },
+    "bge-m3": { dimension: 1024, scoreThreshold: 0.3, maxInputTokens: 8192, normalized: true, kiloMirror: false },
   },
   gemini: {
-    "gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35 },
-    "text-embedding-004": { dimension: 768, scoreThreshold: 0.35 },
-    "embedding-001": { dimension: 768, scoreThreshold: 0.35 },
+    // gemini-embedding-001 accepts only 2048 tokens, the tightest cloud ceiling here.
+    // gemini-embedding-2 takes 8192 and is the better default despite costing more.
+    "gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 2048 },
+    "gemini-embedding-2": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true, kiloMirror: false },
+    "text-embedding-004": { dimension: 768, scoreThreshold: 0.35, maxInputTokens: 2048 },
+    "embedding-001": { dimension: 768, scoreThreshold: 0.35, maxInputTokens: 2048 },
   },
   mistral: {
-    "codestral-embed-2505": { dimension: 1536, scoreThreshold: 0.35 },
-    "codestral-embed": { dimension: 1536, scoreThreshold: 0.35 },
-    "mistral-embed": { dimension: 1024, scoreThreshold: 0.35 },
+    "codestral-embed-2505": { dimension: 1536, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
+    "codestral-embed": { dimension: 1536, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
+    "mistral-embed": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
   },
   voyage: {
-    "voyage-code-3": { dimension: 1024, scoreThreshold: 0.35 },
-    "voyage-3": { dimension: 1024, scoreThreshold: 0.35 },
-    "voyage-3-lite": { dimension: 512, scoreThreshold: 0.35 },
+    // 32k of context on a code-specific model: four times any other entry here, and
+    // the reason voyage is a better default than codestral for code chunks.
+    "voyage-code-4": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true, kiloMirror: false },
+    "voyage-code-3": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true },
+    "voyage-4-large": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true, kiloMirror: false },
+    "voyage-4": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 320_000, normalized: true, kiloMirror: false },
+    "voyage-4-lite": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 1_000_000, normalized: true, kiloMirror: false },
+    "voyage-3": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, normalized: true },
+    "voyage-3-lite": { dimension: 512, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, normalized: true },
   },
   openrouter: {
-    "openai/text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4 },
-    "openai/text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4 },
-    "google/gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35 },
+    "openai/text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchTokens: 300_000 },
+    "openai/text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchTokens: 300_000 },
+    // Kilo's registry names this `google/gemini-embedding-2-preview`. Ours said
+    // `google/gemini-embedding-001`, which can never match a Kilo index: the
+    // profile comparison is exact string equality, so the drift was invisible and
+    // simply made every Gemini-via-OpenRouter index un-importable.
+    "google/gemini-embedding-2-preview": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 8192 },
   },
+  // Kilo's registry also lists `bedrock` and `vercel-ai-gateway`. Both are
+  // deliberately absent: bedrock needs SigV4 request signing, and neither is a
+  // provider this plugin offers. A catalog entry with no implemented adapter is
+  // worse than a missing model, because it looks selectable and then fails.
   "openai-compatible": {},
 }
 
@@ -49,6 +78,7 @@ const defaults: Record<string, string> = {
   gemini: "gemini-embedding-001",
   mistral: "codestral-embed-2505",
   voyage: "voyage-code-3",
+  bedrock: "amazon.titan-embed-text-v2:0",
   openrouter: "openai/text-embedding-3-small",
   "openai-compatible": "",
 }
@@ -59,6 +89,15 @@ export const DEFAULT_EMBEDDING_BATCH_SIZE = 60
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 1024 * 1024
 export const MAX_SEARCH_RESULTS = 200
 
+/**
+ * Ceiling used when a model is not in the catalog.
+ *
+ * `mxbai-embed-large` takes 512 tokens, and Ollama truncates anything longer
+ * without saying so. For an unknown model the safe assumption is the tightest
+ * documented one: a shorter index beat a silently wrong index.
+ */
+export const FALLBACK_MAX_INPUT_TOKENS = 512
+
 /** Scanner extension allowlist mirrored from Kilo's tree-sitter index. */
 export const DEFAULT_SCANNER_EXTENSIONS: readonly string[] = [
   ".bash",
@@ -145,6 +184,41 @@ export function getDefaultModelId(provider: EmbedderProvider): string {
   return defaults[provider] ?? ""
 }
 
+/**
+ * Providers whose adapter has been exercised against the real service.
+ *
+ * Not a quality judgement, a statement of fact. The others were written from
+ * each provider's documentation and tested against fixtures written alongside
+ * them, so a wrong assumption about a field name or a response shape would pass
+ * every test and fail on first use. Surfacing that where a provider is chosen is
+ * cheaper than letting a user discover it from a failed indexing run.
+ */
+export const LIVE_TESTED_PROVIDERS: ReadonlySet<string> = new Set(["mistral"])
+
+export function isLiveTested(provider: EmbedderProvider): boolean {
+  return LIVE_TESTED_PROVIDERS.has(provider)
+}
+
+/**
+ * Every model id the catalog knows for a provider, in catalog order.
+ */
+export function listModelIds(provider: EmbedderProvider): string[] {
+  return Object.keys(profiles[provider] ?? {})
+}
+
+/**
+ * Whether an index built with this profile could ever be imported from Kilo.
+ *
+ * `undefined` means the profile is unknown to us, which is a different thing
+ * from "not importable": a model we have never heard of may still be exactly
+ * what a Kilo index holds.
+ */
+export function isKiloMirrored(provider: EmbedderProvider, modelId: string): boolean | undefined {
+  const profile = getModelProfile(provider, modelId)
+  if (!profile) return undefined
+  return profile.kiloMirror !== false
+}
+
 export function getModelProfile(provider: EmbedderProvider, modelId: string): ModelProfile | undefined {
   return profiles[provider]?.[modelId]
 }
@@ -161,6 +235,18 @@ export function getModelQueryPrefix(provider: EmbedderProvider, modelId: string)
   return getModelProfile(provider, modelId)?.queryPrefix
 }
 
+/**
+ * Largest input the model accepts, in tokens.
+ *
+ * Falls back to the most conservative ceiling any catalog model has, rather than
+ * the most generous: guessing high means sending a 32,000-character chunk to a
+ * model that accepts 512, which comes back silently truncated and gets indexed
+ * as if it covered the whole function.
+ */
+export function getModelMaxInputTokens(provider: EmbedderProvider, modelId: string): number {
+  return getModelProfile(provider, modelId)?.maxInputTokens ?? FALLBACK_MAX_INPUT_TOKENS
+}
+
 /** sha256 hex of a workspace path (no normalization, mirrors Kilo). */
 export function workspaceHash(root: string): string {
   return createHash("sha256").update(root).digest("hex")

package/src/rpc.ts

@@ -32,8 +32,7 @@ const settingsShape = {
     importFromKilo: { type: "boolean" },
     autoRefresh: { type: "boolean" },
     searchMaxResults: { type: "number" },
-    hasMistralKey: { type: "boolean" },
-    hasOpenAiKey: { type: "boolean" },
+    configuredProviders: { type: "array", items: { type: "string" } },
     settingsFile: { type: "string" },
   },
   required: ["vectorStore", "qdrantUrl", "provider", "importFromKilo", "settingsFile"],

package/src/search.ts

@@ -8,6 +8,7 @@ import { getModelScoreThreshold, profileKey, workspaceHash } from "./registry.ts
 import { withProfile } from "./config.ts"
 import type { EmbedderProvider, IndexingSettings, KVStore, QueryHit, SearchHit } from "./types.ts"
 import type { Qdrant } from "./qdrant.ts"
+import type { VectorStoreAdapter } from "./vector-store.ts"
 import { describeError } from "./errors.ts"
 
 export interface SearchDeps {
@@ -15,6 +16,13 @@ export interface SearchDeps {
   kv: KVStore
   root: string
   settings: IndexingSettings
+  /**
+   * The own-index store. Built from the settings when omitted.
+   *
+   * Injected so a caller that already holds one does not build a second
+   * identical client, and so the search can be exercised without a server.
+   */
+  ownStore?: VectorStoreAdapter
 }
 
 export interface SearchMeta {
@@ -80,7 +88,7 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
   const errors: string[] = []
   const limit = Math.max(1, Math.min(overrideLimit ?? settings.searchMaxResults, 200))
 
-  const ownStore = createOwnStore(settings, root)
+  const ownStore = deps.ownStore ?? createOwnStore(settings, root)
   const qdrantClient = settings.vectorStore === "qdrant" ? qdrant : createSettingsQdrant(settings)
   const [ownInfo, kiloCollection] = await Promise.all([
     ownStore.info().catch(() => null),
@@ -102,6 +110,7 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
   if (!profiles.has(profileKey(baseProfile))) profiles.set(profileKey(baseProfile), baseProfile)
 
   const vectors = new Map<string, number[]>()
+  const embedFailures = new Map<string, string>()
   for (const [key, profile] of profiles) {
     try {
       const embedder = createEmbedder(withProfile(settings, profile))
@@ -109,10 +118,32 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
       if (!vector) throw new Error("empty embedding")
       vectors.set(key, vector)
     } catch (error) {
-      errors.push(`embed ${key}: ${describeError(error)}`)
+      embedFailures.set(key, describeError(error))
     }
   }
 
+  /**
+   * Refuse to answer from part of the corpus.
+   *
+   * A stored index whose profile cannot be embedded is unreachable, and
+   * returning only the half that worked looks exactly like a complete answer
+   * whose other half ranked lower. The caller asked what matches, not what
+   * matches in whichever part happened to be readable, so this is an error.
+   * An index with no points needs no query vector and is not a problem.
+   */
+  const unreachable = (label: string, profile: ProfileRef | undefined, points: number | null | undefined): void => {
+    if (!profile || (points ?? 0) <= 0) return
+    const key = profileKey(profile)
+    if (vectors.has(key)) return
+    const cause = embedFailures.get(key)
+    throw new Error(
+      `Cannot search ${label}: it holds ${points} points built with ${key}, and that profile could not be embedded` +
+        `${cause ? ` (${cause})` : ""}. Searching only the other index would return an incomplete result set as if it were complete.`,
+    )
+  }
+  unreachable("the own index", ownInfo?.profile, ownInfo?.pointsCount)
+  unreachable("Kilo's index", kiloInfo?.profile, kiloInfo?.pointsCount)
+
   const minScore = settings.searchMinScore
 
   const kiloHits = (async (): Promise<SearchHit[]> => {
@@ -129,6 +160,11 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
     })
     return hits.map((hit) => toSearchHit(hit, "kilo")).filter((hit): hit is SearchHit => hit !== undefined)
   })().catch((error) => {
+    // Kilo's index exists and holds points; failing to read it would drop those
+    // results from an answer that still looks complete.
+    if ((kiloInfo?.pointsCount ?? 0) > 0) {
+      throw new Error(`Cannot read Kilo's index (${kiloCollection}): ${describeError(error)}`)
+    }
     errors.push(`kilo search: ${describeError(error)}`)
     return [] as SearchHit[]
   })
@@ -147,6 +183,9 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
     })
     return hits.map((hit) => toSearchHit(hit, "own")).filter((hit): hit is SearchHit => hit !== undefined)
   })().catch((error) => {
+    if ((ownInfo?.pointsCount ?? 0) > 0) {
+      throw new Error(`Cannot read the own index (${ownStore.name}): ${describeError(error)}`)
+    }
     errors.push(`own search: ${describeError(error)}`)
     return [] as SearchHit[]
   })

package/src/settings-commands.ts

@@ -172,10 +172,12 @@ const KEY_SPECS: Record<string, KeySpec> = {
     description: "Embedding provider",
     toPatch: (value) => {
       const provider = value as (typeof PROVIDERS)[number]
-      // Reset the model so the provider default applies unless the user sets
-      // one explicitly afterwards.
-      void provider
-      return { provider: provider as SettingsFile["provider"] }
+      // Clear the model so the new provider's default applies. Model ids are
+      // namespaced per provider, so keeping the old one is never right: it
+      // turned a switch to Voyage into `voyage` + `codestral-embed-2505`. The
+      // previous code claimed to do this and returned only the provider, which
+      // left the stale model in the file and outranked the default.
+      return { provider: provider as SettingsFile["provider"], model: "" }
     },
     display: (settings) => settings.provider,
   },

package/src/settings.ts

@@ -93,6 +93,18 @@ function compact<T extends Record<string, unknown>>(input: T): T {
   return out as T
 }
 
+/**
+ * Merge the two objects a level deep.
+ *
+ * Derived from the incoming keys rather than listing the provider names here.
+ * The hand-written list this replaced silently dropped any credential added to
+ * the shape but not to the list: the field existed, the resolver read it, and
+ * the value never reached the file.
+ */
+function mergeNested<T extends Record<string, unknown>>(current: T | undefined, incoming: T): T {
+  return compact({ ...(current ?? {}), ...incoming }) as T
+}
+
 function deepMerge(base: SettingsFile, patch: SettingsFile): SettingsFile {
   const out: SettingsFile = { ...base }
   for (const [key, value] of Object.entries(patch)) {
@@ -108,19 +120,22 @@ function deepMerge(base: SettingsFile, patch: SettingsFile): SettingsFile {
     if (key === "apiKeys") {
       const current = out.apiKeys ?? {}
       const incoming = value as NonNullable<SettingsFile["apiKeys"]>
-      out.apiKeys = compact({
-        ...current,
-        mistral: incoming.mistral ?? current.mistral,
-        openai: incoming.openai ?? current.openai,
-        gemini: incoming.gemini ?? current.gemini,
-        voyage: incoming.voyage ?? current.voyage,
-        openrouter: incoming.openrouter ?? current.openrouter,
-        ollama: incoming.ollama !== undefined ? compact({ ...current.ollama, ...incoming.ollama }) : current.ollama,
-        "openai-compatible":
-          incoming["openai-compatible"] !== undefined
-            ? compact({ ...current["openai-compatible"], ...incoming["openai-compatible"] })
-            : current["openai-compatible"],
-      }) as SettingsFile["apiKeys"]
+      const merged: Record<string, unknown> = { ...current }
+      for (const [provider, providerValue] of Object.entries(incoming)) {
+        if (providerValue === undefined) continue
+        // ollama and openai-compatible are objects; the rest are plain keys.
+        // Both shapes merge the same way, so no per-provider branch is needed.
+        merged[provider] =
+          typeof providerValue === "object" && providerValue !== null
+            ? mergeNested(
+                typeof merged[provider] === "object" && merged[provider] !== null
+                  ? (merged[provider] as Record<string, unknown>)
+                  : undefined,
+                providerValue as Record<string, unknown>,
+              )
+            : providerValue
+      }
+      out.apiKeys = compact(merged) as SettingsFile["apiKeys"]
       continue
     }
     ;(out as Record<string, unknown>)[key] = value

package/src/status.ts

@@ -5,10 +5,11 @@ import { getKiloStoreInfo, resolveKiloCollection } from "./kilo-store.ts"
 import { discoverKiloSources, type KiloSourceInfo } from "./import.ts"
 import { createOwnStore, createSettingsQdrant } from "./store-factory.ts"
 import { diffFiles, loadManifest } from "./manifest.ts"
-import { workspaceHash } from "./registry.ts"
+import { getModelDimension, profileKey, workspaceHash } from "./registry.ts"
 import { scanWorkspace } from "./scanner.ts"
 import type { IndexingSettings, KVStore } from "./types.ts"
 import type { Qdrant } from "./qdrant.ts"
+import type { VectorStoreAdapter } from "./vector-store.ts"
 import { describeError } from "./errors.ts"
 
 export interface StatusDeps {
@@ -16,6 +17,8 @@ export interface StatusDeps {
   kv: KVStore
   root: string
   settings: IndexingSettings
+  /** The own-index store. Built from the settings when omitted. */
+  ownStore?: VectorStoreAdapter
 }
 
 export interface IndexStatus {
@@ -78,7 +81,7 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     }
   }
 
-  const ownStore = createOwnStore(settings, root)
+  const ownStore = deps.ownStore ?? createOwnStore(settings, root)
   const cacheKey = KILO_CACHE_PREFIX + workspaceHash(root).slice(0, 16)
   const cachedKilo = await kv.get(cacheKey)
   const kiloCollection = reachable
@@ -123,8 +126,40 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     : null
 
   const compatibleSource = kiloSources.find((source) => source.compatible)
+
+  /**
+   * A profile change destroys the own index and re-embeds everything.
+   *
+   * Saying so here is the point: the rebuild happens on the next build or
+   * refresh, so a user who changes provider to save money can spend the whole
+   * repository on embeddings before seeing any indication that it happened.
+   * The count is reported because it is the only estimate of the cost.
+   */
+  const configuredProfile = {
+    provider: settings.provider,
+    modelId: settings.modelId,
+    dimension: settings.dimension || getModelDimension(settings.provider, settings.modelId) || 0,
+  }
+  const storedProfile = ownInfo?.profile
+  const profileChanged =
+    storedProfile !== undefined &&
+    (storedProfile.provider !== configuredProfile.provider ||
+      storedProfile.modelId !== configuredProfile.modelId ||
+      (configuredProfile.dimension > 0 && storedProfile.dimension !== configuredProfile.dimension))
+  if (profileChanged && (ownInfo?.pointsCount ?? 0) > 0) {
+    warnings.push(
+      `The own index holds ${ownInfo?.pointsCount} points built with ${profileKey(storedProfile)} but the configured ` +
+        `model is ${profileKey(configuredProfile)}. The next build or refresh will delete them and re-embed the whole ` +
+        `workspace. Set the model back to reuse them, or re-import from Kilo if a matching source exists.`,
+    )
+  }
+
   let recommendation: string
-  if (!reachable && settings.vectorStore === "qdrant") {
+  if (profileChanged) {
+    recommendation =
+      `The embedding model changed since the own index was built (${profileKey(storedProfile!)} -> ` +
+      `${profileKey(configuredProfile)}). Run indexing_build to rebuild it, which re-embeds every file.`
+  } else if (!reachable && settings.vectorStore === "qdrant") {
     recommendation = "Start Qdrant (e.g. `docker run -p 6333:6333 qdrant/qdrant` or Podman equivalent), then re-run indexing_status."
   } else if (!kiloCollection && !ownInfo?.exists && kiloSources.length === 0) {
     recommendation = "No index found. Run indexing_build to create an independent index (works without Kilo Code)."

package/src/types.ts

@@ -22,6 +22,38 @@ export interface ModelProfile {
   dimension: number
   scoreThreshold?: number
   queryPrefix?: string
+  /**
+   * Largest input the model accepts, in tokens.
+   *
+   * Not the same for every model, and the spread is wide: `mxbai-embed-large`
+   * takes 512 while `voyage-code-4` takes 32,000. Sizing every request by one
+   * global constant silently truncates every chunk past the smallest model's
+   * limit, and that truncated vector is stored as if it covered the whole
+   * function.
+   */
+  maxInputTokens?: number
+  /** Documented ceiling on items in one request, where the provider publishes one. */
+  maxBatchItems?: number
+  /** Documented ceiling on tokens in one request, where the provider publishes one. */
+  maxBatchTokens?: number
+  /**
+   * Whether the provider documents its output as already L2-normalised.
+   *
+   * The provider's claim, not a measurement we rely on. Mistral documents its
+   * embeddings as "norm 1" and a live call measured 0.9913, which is why every
+   * comparison here uses cosine regardless: it is correct either way, and this
+   * field exists only so a future fast path knows whether a bare dot product
+   * would be equivalent.
+   */
+  normalized?: boolean
+  /**
+   * Marks a model we know about that Kilo's registry does not.
+   *
+   * The catalog is a mirror, so that query embeddings stay interchangeable with
+   * a Kilo index. An entry with no Kilo counterpart is still useful, but it can
+   * never be import-compatible, and the status report has to be able to say so.
+   */
+  kiloMirror?: boolean
 }
 
 export interface ProviderCredentials {

package/tui/settings-page-data.ts

@@ -24,8 +24,8 @@ export interface SettingsView {
   /** Master switch for writing the own index. */
   enabled: boolean
   searchMaxResults: number
-  hasMistralKey: boolean
-  hasOpenAiKey: boolean
+  /** Providers that have a usable credential or base URL configured. */
+  configuredProviders: string[]
   settingsFile: string
 }
 
@@ -101,8 +101,7 @@ export const UNKNOWN_SETTINGS: SettingsView = {
   enabled: false,
   autoRefresh: false,
   searchMaxResults: 0,
-  hasMistralKey: false,
-  hasOpenAiKey: false,
+  configuredProviders: [],
   settingsFile: "(unavailable)",
 }
 
@@ -149,10 +148,10 @@ export function configRows(settings: SettingsView): ConfigRow[] {
     { label: "Max results", value: String(settings.searchMaxResults) },
     { label: "Settings file", value: settings.settingsFile },
   ]
-  const keys: string[] = []
-  if (settings.hasMistralKey) keys.push("mistral")
-  if (settings.hasOpenAiKey) keys.push("openai")
-  rows.push({ label: "API keys", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
+  // Derived from the server's list rather than a pair of booleans, so a
+  // provider added anywhere else shows up here without a change to this file.
+  const keys = settings.configuredProviders
+  rows.push({ label: "Credentials", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
   return rows
 }
 

package/tui.ts

@@ -28,6 +28,8 @@ import { describeRow, forgetWorkspaceFlow, type WorkspacesRpc } from "./tui/work
 import { pagePalette } from "./tui/page-style.ts"
 import type { FooterHandle, FooterState } from "./tui/footer-view.tsx"
 import { describeError } from "./src/errors.ts"
+import { getDefaultModelId, isLiveTested, listModelIds } from "./src/registry.ts"
+import type { EmbedderProvider } from "./src/types.ts"
 
 /**
  * Navigable rows on the page.
@@ -40,6 +42,9 @@ const PAGE_ROW_COUNT = PAGE_ROWS.length
 
 const ID = "opencode.indexing"
 
+/** Sentinel for the "type it yourself" entry in the model chooser. */
+const CUSTOM_MODEL = "\u0000custom-model"
+
 type RpcClient = {
   "settings.get": (input: Record<string, never>) => Promise<{ settings: SettingsView }>
   "settings.set": (input: { patch: Record<string, unknown> }) => Promise<{ settings: SettingsView }>
@@ -64,8 +69,8 @@ interface SettingsView {
   /** Master switch for writing the own index. */
   enabled: boolean
   searchMaxResults: number
-  hasMistralKey: boolean
-  hasOpenAiKey: boolean
+  /** Providers that have a usable credential or base URL configured. */
+  configuredProviders: string[]
   settingsFile: string
 }
 
@@ -334,13 +339,49 @@ const plugin = {
       })
       if (typeof provider !== "string") return
 
-      const model = await context.ui.dialog.prompt({
-        title: `Model for ${provider} (leave empty for default)`,
-        placeholder: provider === "mistral" ? "codestral-embed-2505" : "",
+      // Offer the catalog instead of a blank text field. The model list existed
+      // all along and was never shown, so the only way to discover a valid model
+      // id was to already know it.
+      const catalog = listModelIds(provider as EmbedderProvider)
+      const defaultModel = getDefaultModelId(provider as EmbedderProvider)
+      const tested = isLiveTested(provider as EmbedderProvider)
+      const choice = await context.ui.dialog.select({
+        title: `Model for ${provider}`,
+        options: [
+          {
+            title: defaultModel ? `${defaultModel} (default)` : "(provider default)",
+            value: "",
+            description: tested
+              ? "Leave the model unset so the provider default applies"
+              : "Not yet exercised against the real API; see the README",
+          },
+          ...catalog
+            .filter((modelId) => modelId !== defaultModel)
+            .map((modelId) => ({ title: modelId, value: modelId, description: `${provider} model` })),
+          {
+            title: "Custom…",
+            value: CUSTOM_MODEL,
+            description: catalog.length > 0 ? "Type a model id that is not in the list" : "This provider has no catalog; type the model id",
+          },
+        ],
       })
-      const patch: Record<string, unknown> = { provider }
-      if (model && model.trim()) patch.model = model.trim()
-      await patchSettings(patch)
+      if (typeof choice !== "string") return
+
+      let model = choice
+      if (choice === CUSTOM_MODEL) {
+        const typed = await context.ui.dialog.prompt({
+          title: `Model id for ${provider}`,
+          placeholder: defaultModel || "e.g. bge-m3",
+        })
+        if (typed === undefined) return
+        model = typed.trim()
+      }
+
+      // `model` is always written, empty when the user accepted the default.
+      // Omitting it left the previous provider's model in the file, where it
+      // outranks the new provider's default: switching to voyage produced
+      // `voyage` + `codestral-embed-2505`.
+      await patchSettings({ provider, model })
 
       // API key for the provider (masked prompt).
       const keyLabel =
@@ -357,7 +398,7 @@ const plugin = {
                   : null
 
       if (keyLabel) {
-        const current = provider === "mistral" && settings.hasMistralKey
+        const current = settings.configuredProviders.includes(provider)
         const key = await context.ui.dialog.prompt({
           title: `${keyLabel} (leave empty to keep current)`,
           placeholder: current ? "•••••• (set)" : "not set",