Custom connections are gone: the CLI talks to the LLeMbas server it is logged in to

LLeMbas CLI 2.0 is LLeMbas-server-specific (CLI rule 2). Removed: the
anthropic, gemini, ollama and responses clients, context discovery and
llama-swap unloading (discover.ts), the Connection schema with its dialect,
auth, key_cmd, discover, unload_url and one_model_at_a_time, the model
`fallback` (it only ever moved to another server), effort_map and cache, and
the multi-connection refs. Kept: openai-chat, http, sse, think, effort,
tokens and all of src/lembas.

- connections.yaml holds the login (`type: webui`, as lembas login writes
  it). A custom entry from 1.x is read past with a warning that says how to
  log in, so an old file still starts; with several logins left, the latest
  is used and the others named.
- A model's ref is the id the server serves it under; the older forms
  (`<login>/<id>`, `<login>/<model>`) still resolve and config.yaml is
  rewritten once. Without a login there is no model, and the error (and the
  first-run screen, now the sign-in alone) says `lembas login <address>`.
- A login to another server signs this machine out of the previous one.
- The window is the server's word (no discovery); a capacity group comes
  from the server's `capacity.group` alone; embeddings use the server's
  /v1/embeddings.
- `lembas models` lists the server's models; install.sh's starter files, the
  README and the JSON schemas say the same.

Tests: every fixture is a login now (the fake server lists models, answers
other GETs with 404, and can hand one model to another script, as a server
with several backends); the dialect suites and the cross-connection tests are
gone with their code.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/provider/index.ts

@@ -1,64 +1,40 @@
 import { findRef, modelRefs } from "./refs.ts"
 import type { Loaded } from "../config/load.ts"
-import { AnthropicClient } from "./anthropic.ts"
 import { OpenAIChatClient } from "./openai-chat.ts"
-import { ResponsesClient } from "./responses.ts"
-import { GeminiClient } from "./gemini.ts"
-import { OllamaClient } from "./ollama.ts"
-import { ProviderError, type Client, type ResolvedModel } from "./types.ts"
+import type { Client, ResolvedModel } from "./types.ts"
 
 export class ModelError extends Error {}
 
-/** `connection/model`. The model part may itself contain slashes (`openrouter/qwen/qwen3-coder`). */
+/** What a start without a login says: LLeMbas CLI 2.0 has no model of its own, only the server's. */
+export const NOT_LOGGED_IN = "Not logged in to a LLeMbas server. LLeMbas CLI uses the models of the server it is logged in to: lembas login <address> (e.g. lembas login ai.example.org)."
+
+/** A model of the server this machine is logged in to, by its served id (`deepseek/deepseek-flash`)
+ *  or an older form of its name (refs.ts). Without a ref: config.yaml's `model`, else the server's
+ *  default for the account, else its first. */
 export function resolveModel(loaded: Loaded, ref: string | undefined): ResolvedModel {
   const refs = loaded.refs ?? modelRefs(loaded.connections)
-  if (!ref) {
-    // A LLeMbas instance says which model its account starts on; that, before anything else.
-    const instance = Object.entries(loaded.connections).find(([, c]) => c.webui?.default && c.models[c.webui.default])
-    if (instance) ref = refs.find((r) => r.connection === instance[0] && r.id === instance[1].webui!.default)?.ref ?? `${instance[0]}/${instance[1].webui!.default}`
+  const [name, connection] = Object.entries(loaded.connections)[0] ?? []
+  if (!name || !connection) {
+    const why = Object.values(loaded.broken ?? {})[0]
+    throw new ModelError(why ? `The LLeMbas login is unusable: ${why}` : NOT_LOGGED_IN)
   }
-  if (!ref) {
-    const first = refs[0]
-    if (!first) throw new ModelError("No model configured. Add a connection to ~/.config/lembas/connections.yaml and set `model:` in config.yaml.")
-    ref = first.ref
-  }
-  // Any form of the name (`deepseek/x`, or the old `example/x`): the model it names, under
-  // the ref it has now.
+  if (loaded.broken?.[name]) throw new ModelError(`The LLeMbas login ${name} is unusable: ${loaded.broken[name]}`)
+  if (!ref) ref = connection.webui?.default && connection.models[connection.webui.default] ? connection.webui.default : refs[0]?.ref
+  if (!ref) throw new ModelError(`${name} serves no model to this account yet. lembas login ${connection.webui?.url ?? ""} again once it does.`.replace("  ", " "))
   const known = findRef(loaded.connections, refs, ref)
-  if (known) {
-    const connection = loaded.connections[known.connection]!
-    if (loaded.broken?.[known.connection]) throw new ModelError(`Connection "${known.connection}" is unusable: ${loaded.broken?.[known.connection]}`)
-    return { ref: known.ref, connectionName: known.connection, connection, id: known.id, spec: connection.models[known.id] ?? {} }
-  }
-  const slash = ref.indexOf("/")
-  if (slash <= 0) throw new ModelError(`Model "${ref}" must be written connection/model`)
-  const connectionName = ref.slice(0, slash)
-  const id = ref.slice(slash + 1)
-  if (loaded.broken?.[connectionName]) throw new ModelError(`Connection "${connectionName}" is unusable: ${loaded.broken[connectionName]}`)
-  const connection = loaded.connections[connectionName]
-  if (!connection) throw new ModelError(`No connection named "${connectionName}" (have: ${Object.keys(loaded.connections).join(", ") || "none"})`)
-  const spec = connection.models[id]
-  if (!spec && !connection.discover)
-    throw new ModelError(`Connection "${connectionName}" has no model "${id}" (have: ${Object.keys(connection.models).join(", ") || "none"}). Add it, or set discover: true.`)
-  return { ref, connectionName, connection, id, spec: spec ?? {} }
+  if (known) return { ref: known.ref, connectionName: name, connection, id: known.id, spec: connection.models[known.id] ?? {} }
+  // A model the server serves that its list did not have when it was read: the server decides
+  // which models exist, so it is asked for rather than refused here. The login's own name in front
+  // of it (an older form) is taken off.
+  const id = ref.startsWith(`${name}/`) ? ref.slice(name.length + 1) : ref
+  return { ref: id, connectionName: name, connection, id, spec: {} }
 }
 
 export function clientFor(m: ResolvedModel): Client {
-  switch (m.connection.dialect) {
-    case "openai-chat":
-      return new OpenAIChatClient(m)
-    case "anthropic":
-      return new AnthropicClient(m)
-    case "responses":
-      return new ResponsesClient(m)
-    case "gemini":
-      return new GeminiClient(m)
-    case "ollama":
-      return new OllamaClient(m)
-  }
+  return new OpenAIChatClient(m)
 }
 
-/** Which prompt family a model gets when the config does not say: anthropic, gpt, gemini, or
+/** Which prompt family a model gets when the server does not say: anthropic, gpt, gemini, or
  *  local — every open-weight or unknown model, which gets Hermes' act-don't-describe guidance. */
 export function familyOf(m: ResolvedModel): string {
   if (m.spec.family) return m.spec.family
@@ -68,3 +44,9 @@ export function familyOf(m: ResolvedModel): string {
   if (/\bgpt|^o[134]\b|^o[134]-|codex/.test(id)) return "gpt"
   return "local"
 }
+
+/** The window to plan with, as the server gives it; undefined when it does not say (no percentage,
+ *  no automatic compaction). */
+export function contextWindow(m: ResolvedModel): number | undefined {
+  return m.spec.context || undefined
+}