HomerandClaude Opus 5.5
f9bad01ed7
ci / check (push) Waiting to run
The first public release of LLeMbas CLI: a terminal coding agent and project manager for any LLM API, with permission modes, git snapshots, memory and skills, knowledge bases, MCP, voice, and a link to a LLeMbas instance whose web UI can work its sessions too. Signed Linux binaries for x64 and arm64. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
233 lines
15 KiB
TypeScript
233 lines
15 KiB
TypeScript
// Models from a LLeMbas instance named by their provider: `deepseek/deepseek-flash`, not
|
|
// `example/deepseek-flash`. The old forms still resolve, a config naming one is rewritten, a
|
|
// connection of the user's own wins its name, two instances share a provider by login order, and an
|
|
// instance that does not speak protocol 2 (bare ids) keeps `<login>/<id>`. On the link, the model event and the
|
|
// announcement say whether the session's model is this link's instance's.
|
|
import { afterEach, beforeEach, expect, test } from "bun:test"
|
|
import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs"
|
|
import { tmpdir } from "node:os"
|
|
import { join } from "node:path"
|
|
import { AcpAgent } from "../src/acp/agent.ts"
|
|
import { Hub } from "../src/acp/hub.ts"
|
|
import { Share } from "../src/acp/share.ts"
|
|
import { Peer, type Transport } from "../src/acp/rpc.ts"
|
|
import { createApp } from "../src/app.ts"
|
|
import { loadConfig } from "../src/config/load.ts"
|
|
import { paths } from "../src/config/paths.ts"
|
|
import { writeCache } from "../src/lembas/webui.ts"
|
|
import { setTrust } from "../src/project/root.ts"
|
|
import { resolveModel } from "../src/provider/index.ts"
|
|
import { findRef, modelRefs } from "../src/provider/refs.ts"
|
|
import { embedderFor } from "../src/library/embed.ts"
|
|
import { delta, fakeProvider, type Fake } from "./fake-provider.ts"
|
|
|
|
let fake: Fake | undefined
|
|
beforeEach(() => clean())
|
|
afterEach(() => {
|
|
fake?.stop()
|
|
fake = undefined
|
|
clean()
|
|
})
|
|
function clean() {
|
|
rmSync(join(paths.state, "migrations.json"), { force: true })
|
|
rmSync(join(paths.config, "lembas.json"), { force: true })
|
|
rmSync(join(paths.config, "lembas"), { recursive: true, force: true })
|
|
rmSync(join(paths.state, "webui"), { recursive: true, force: true })
|
|
}
|
|
|
|
const conns = (o: Record<string, { webui?: boolean; models: string[] }>) =>
|
|
Object.fromEntries(Object.entries(o).map(([n, c]) => [n, { dialect: "openai-chat", base_url: "http://x/v1", models: Object.fromEntries(c.models.map((m) => [m, {}])), ...(c.webui ? { webui: { url: "http://x", v2: true } } : {}) }])) as never
|
|
|
|
test("refs: by provider; a connection of the user's own wins its name; a bare id keeps the login", () => {
|
|
const c = conns({ example: { webui: true, models: ["deepseek/deepseek-flash", "llama/bonsai", "old"] }, llama: { models: ["mine"] } })
|
|
const refs = modelRefs(c, ["example"])
|
|
expect(refs.map((r) => r.ref)).toEqual(["deepseek/deepseek-flash", "example/llama/bonsai", "example/old", "llama/mine"])
|
|
// Every old way of writing them.
|
|
expect(findRef(c, refs, "example/deepseek-flash")?.ref).toBe("deepseek/deepseek-flash")
|
|
expect(findRef(c, refs, "example/deepseek/deepseek-flash")?.ref).toBe("deepseek/deepseek-flash")
|
|
expect(findRef(c, refs, "example/bonsai")?.ref).toBe("example/llama/bonsai")
|
|
expect(findRef(c, refs, "llama/mine")).toMatchObject({ connection: "llama", id: "mine" })
|
|
expect(findRef(c, refs, "llama/bonsai")).toBeUndefined()
|
|
})
|
|
|
|
test("refs: two instances with one provider — the first logged in to keeps the short form", () => {
|
|
const c = conns({ example: { webui: true, models: ["deepseek/a"] }, work: { webui: true, models: ["deepseek/a", "openai/b"] } })
|
|
expect(modelRefs(c, ["example", "work"]).map((r) => r.ref)).toEqual(["deepseek/a", "work/deepseek/a", "openai/b"])
|
|
expect(modelRefs(c, ["work", "example"]).map((r) => r.ref)).toEqual(["example/deepseek/a", "deepseek/a", "openai/b"])
|
|
// A login named after its own provider: the same string either way.
|
|
expect(modelRefs(conns({ llama: { webui: true, models: ["llama/bonsai"] } }), ["llama"]).map((r) => r.ref)).toEqual(["llama/bonsai"])
|
|
})
|
|
|
|
/** Logged in to an instance served by `fake`, whose models are `models` (as /v1/models said them;
|
|
* `provider` given for an id with a `/` unless `o.noProvider`, and `o.protocols` as discovery said). */
|
|
function loggedIn(models: string[], extra = "", o: { noProvider?: boolean; protocols?: number[] } = {}) {
|
|
mkdirSync(join(paths.config, "lembas"), { recursive: true })
|
|
const key = join(paths.config, "lembas", "example.key")
|
|
writeFileSync(key, "lmb_key\n", { mode: 0o600 })
|
|
const url = fake!.url.replace(/\/v1$/, "")
|
|
writeFileSync(join(paths.config, "lembas.json"), JSON.stringify({ instances: { example: { base_url: url, connection: "example", logged_in_at: "", ...(o.protocols ? { protocols: o.protocols } : {}) } } }))
|
|
writeFileSync(join(paths.config, "connections.yaml"), `connections:\n example:\n type: webui\n url: ${url}\n api_key: "{file:${key}}"\n${extra}`, { mode: 0o600 })
|
|
writeCache("example", { fetched_at: new Date().toISOString(), url, models: models.map((id) => ({ id, ...(id.includes("/") && !o.noProvider ? { provider: id.split("/")[0] } : {}) })) })
|
|
}
|
|
|
|
test("logged in: the model is deepseek/deepseek-flash everywhere, requests go to the instance with the served id", async () => {
|
|
fake = fakeProvider([{ chunks: [delta({ content: "from the instance" })] }])
|
|
loggedIn(["deepseek/deepseek-flash", "llama/bonsai"])
|
|
// An old config's ref: still the same model, and the file says the new one now.
|
|
writeFileSync(join(paths.config, "config.yaml"), "# mine\nmodel: example/deepseek-flash\n")
|
|
const loaded = loadConfig()
|
|
expect(loaded.config.model).toBe("deepseek/deepseek-flash")
|
|
expect(readFileSync(join(paths.config, "config.yaml"), "utf8")).toBe("# mine\nmodel: deepseek/deepseek-flash\n")
|
|
const m = resolveModel(loaded, "deepseek/deepseek-flash")
|
|
expect(m).toMatchObject({ ref: "deepseek/deepseek-flash", connectionName: "example", id: "deepseek/deepseek-flash" })
|
|
expect(resolveModel(loaded, "example/deepseek/deepseek-flash").ref).toBe("deepseek/deepseek-flash")
|
|
const cwd = realpathSync(mkdtempSync(join(tmpdir(), "ph-refs-")))
|
|
const app = createApp({ cwd, asker: { ask: async () => ({ kind: "once" }) }, store: false })
|
|
expect(app.engine.model.ref).toBe("deepseek/deepseek-flash")
|
|
expect(app.modelRefs()).toEqual(["deepseek/deepseek-flash", "llama/bonsai"])
|
|
app.switchModel("example/bonsai")
|
|
expect(app.engine.model.ref).toBe("llama/bonsai")
|
|
app.switchModel("deepseek/deepseek-flash")
|
|
await app.engine.prompt("hi")
|
|
expect(fake.requests[0].model).toBe("deepseek/deepseek-flash")
|
|
expect(fake.calls.at(-1)!.headers.authorization).toBe("Bearer lmb_key")
|
|
await app.close()
|
|
})
|
|
|
|
test("an instance that does not speak protocol 2 (bare ids): <login>/<id>", () => {
|
|
fake = fakeProvider([])
|
|
loggedIn(["deepseek-flash"])
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: example/deepseek-flash\n")
|
|
const loaded = loadConfig()
|
|
expect(loaded.refs.map((r) => r.ref)).toEqual(["example/deepseek-flash"])
|
|
expect(resolveModel(loaded, undefined).ref).toBe("example/deepseek-flash")
|
|
expect(readFileSync(join(paths.config, "config.yaml"), "utf8")).toBe("model: example/deepseek-flash\n")
|
|
})
|
|
|
|
test("a connection of the user's own named like a provider keeps it; the instance's is <login>/<provider>/<model>", () => {
|
|
fake = fakeProvider([])
|
|
loggedIn(["deepseek/deepseek-flash"], ` deepseek:\n dialect: openai-chat\n base_url: ${"http://127.0.0.1:9/v1"}\n models: { deepseek-flash: {} }\n`)
|
|
const loaded = loadConfig()
|
|
expect(loaded.refs.map((r) => r.ref)).toEqual(["example/deepseek/deepseek-flash", "deepseek/deepseek-flash"])
|
|
expect(resolveModel(loaded, "deepseek/deepseek-flash").connectionName).toBe("deepseek")
|
|
expect(resolveModel(loaded, "example/deepseek/deepseek-flash").connectionName).toBe("example")
|
|
})
|
|
|
|
function pair(): [Transport, Transport] {
|
|
const make = () => ({ msg: (_: string) => {}, end: () => {} })
|
|
const a = make()
|
|
const b = make()
|
|
const side = (me: typeof a, other: typeof a): Transport => ({ send: (t) => queueMicrotask(() => other.msg(t)), onMessage: (fn) => (me.msg = fn), onClose: (fn) => (me.end = fn), close: () => (me.end(), other.end()) })
|
|
return [side(a, b), side(b, a)]
|
|
}
|
|
|
|
test("on the link: the instance names its model as served, the session reports the provider ref, and says it is the instance's", async () => {
|
|
fake = fakeProvider([])
|
|
loggedIn(["deepseek/deepseek-flash", "llama/bonsai"], ` local:\n dialect: openai-chat\n base_url: http://127.0.0.1:9/v1\n models: { m: {} }\n`)
|
|
writeFileSync(join(paths.config, "config.yaml"), "")
|
|
const root = realpathSync(mkdtempSync(join(tmpdir(), "ph-refs-")))
|
|
setTrust(root, "trusted")
|
|
const [ta, tb] = pair()
|
|
new AcpAgent(new Peer(ta), { roots: [root], maxMode: "edit", approvalTimeoutMs: 1000, requireTrust: true }, "example")
|
|
const c = new Peer(tb)
|
|
const events: any[] = []
|
|
c.on("_lembas/event", (p) => void events.push(p.event))
|
|
c.on("session/update", () => {})
|
|
const init: any = await c.request("initialize", { protocolVersion: 1, clientCapabilities: { _meta: { lembas: { protocol: 2 } } } })
|
|
expect(init._meta.lembas.connection).toBe("example")
|
|
const s: any = await c.request("session/new", { cwd: root, _meta: { lembas_model: "deepseek/deepseek-flash" } })
|
|
expect(s._meta.lembas.model).toBe("deepseek/deepseek-flash")
|
|
// An older instance's bare name, the same model.
|
|
expect(await c.request<any>("_lembas/configure", { sessionId: s.sessionId, model: "bonsai" })).toMatchObject({ model: "llama/bonsai" })
|
|
for (let i = 0; i < 50 && !events.some((e) => e.type === "model"); i++) await Bun.sleep(10)
|
|
expect(events.find((e) => e.type === "model")).toMatchObject({ ref: "llama/bonsai", connection: "example", instance: true })
|
|
})
|
|
|
|
// The audit of 568923c.
|
|
|
|
test("only the old <login>/<model> is rewritten, once, in place: a pinned long form, anchors and comments stay", () => {
|
|
fake = fakeProvider([])
|
|
loggedIn(["deepseek/deepseek-flash", "llama/nomic-embed"])
|
|
// Pinned on purpose: means what it says, and is left alone.
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: example/deepseek/deepseek-flash\n")
|
|
expect(loadConfig().config.model).toBe("example/deepseek/deepseek-flash")
|
|
expect(readFileSync(join(paths.config, "config.yaml"), "utf8")).toBe("model: example/deepseek/deepseek-flash\n")
|
|
// The old form behind an anchor, with a comment: the scalar changes, nothing else.
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: &m example/deepseek-flash # my pick\nsmall_model: *m\nembedding: example/nomic-embed\n")
|
|
const l = loadConfig()
|
|
expect(readFileSync(join(paths.config, "config.yaml"), "utf8")).toBe("model: &m deepseek/deepseek-flash # my pick\nsmall_model: *m\nembedding: example/nomic-embed\n")
|
|
expect(l.config.small_model).toBe("deepseek/deepseek-flash")
|
|
// embedding as written (its name keys the stored vectors), and it still resolves.
|
|
expect(l.config.embedding).toBe("example/nomic-embed")
|
|
expect(embedderFor(l, l.config.embedding)?.model).toBe("example/nomic-embed")
|
|
expect(embedderFor(l, "llama/nomic-embed")).toBeDefined()
|
|
// Once: written back the old way by hand, it is not rewritten again (it still resolves).
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: example/deepseek-flash\n")
|
|
expect(loadConfig().config.model).toBe("deepseek/deepseek-flash")
|
|
expect(readFileSync(join(paths.config, "config.yaml"), "utf8")).toBe("model: example/deepseek-flash\n")
|
|
expect(existsSync(join(paths.state, "migrations.json"))).toBe(true)
|
|
})
|
|
|
|
test("the provider: as the instance says it; from a protocol-2 instance, before the /; else the id is just an id", () => {
|
|
fake = fakeProvider([])
|
|
// Not protocol 2: an id with a / and no provider is `<login>/<id>`.
|
|
loggedIn(["org/model-a"], "", { noProvider: true })
|
|
expect(loadConfig().refs.map((r) => r.ref)).toEqual(["example/org/model-a"])
|
|
// The instance speaks protocol 2: its ids are `<provider>/<model>`.
|
|
loggedIn(["org/model-a"], "", { noProvider: true, protocols: [1, 2] })
|
|
expect(loadConfig().refs.map((r) => r.ref)).toEqual(["org/model-a"])
|
|
// `provider` said: used, whatever the protocol.
|
|
loggedIn(["org/model-a"])
|
|
expect(loadConfig().refs.map((r) => r.ref)).toEqual(["org/model-a"])
|
|
})
|
|
|
|
test("a models: override keyed by the old bare name lands on the served model; no phantom appears", () => {
|
|
fake = fakeProvider([])
|
|
loggedIn(["deepseek/deepseek-flash"], " models: { deepseek-flash: { context: 1000 }, upcoming: { context: 5 } }\n")
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: example/deepseek-flash\n")
|
|
const l = loadConfig()
|
|
expect(l.refs.map((r) => r.ref)).toEqual(["deepseek/deepseek-flash", "example/upcoming"])
|
|
const m = resolveModel(l, l.config.model)
|
|
expect(m).toMatchObject({ id: "deepseek/deepseek-flash", spec: { context: 1000 } })
|
|
})
|
|
|
|
test("_lembas/configure naming a terminal session's own model (as the instance serves it) keeps its effort", async () => {
|
|
fake = fakeProvider([])
|
|
mkdirSync(join(paths.config, "lembas"), { recursive: true })
|
|
const key = join(paths.config, "lembas", "example.key")
|
|
writeFileSync(key, "lmb_key\n", { mode: 0o600 })
|
|
const url = fake.url.replace(/\/v1$/, "")
|
|
writeFileSync(join(paths.config, "lembas.json"), JSON.stringify({ instances: { example: { base_url: url, connection: "example", logged_in_at: "" } } }))
|
|
writeFileSync(join(paths.config, "connections.yaml"), `connections:\n example:\n type: webui\n url: ${url}\n api_key: "{file:${key}}"\n`, { mode: 0o600 })
|
|
writeCache("example", { fetched_at: new Date().toISOString(), url, models: [{ id: "deepseek/deepseek-flash", provider: "deepseek", efforts: ["low", "high"], effort: "low" }] })
|
|
writeFileSync(join(paths.config, "config.yaml"), "model: deepseek/deepseek-flash\n")
|
|
const root = realpathSync(mkdtempSync(join(tmpdir(), "ph-refs-")))
|
|
Bun.spawnSync(["git", "init", "-q", root])
|
|
setTrust(root, "trusted")
|
|
const limits = { roots: [root], maxMode: "auto" as const, approvalTimeoutMs: 3000, requireTrust: true }
|
|
const hub = new Hub({ service: true, limits: { ...limits, enabled: true } })
|
|
expect(await hub.listen()).toBe(true)
|
|
const [ta, tb] = pair()
|
|
new AcpAgent(new Peer(ta), limits, "example", hub)
|
|
const c = new Peer(tb)
|
|
const heard: any[] = []
|
|
c.on("_lembas/session/announce", (p) => void heard.push(p))
|
|
c.on("_lembas/event", () => {})
|
|
c.on("session/update", () => {})
|
|
await c.request("initialize", { protocolVersion: 1, clientCapabilities: { _meta: { lembas: { protocol: 2 } } } })
|
|
const app = createApp({ cwd: root, modelTitles: false, asker: { ask: async () => ({ kind: "once" }) } })
|
|
const share = new Share(app, { prompt: async () => "stop", compact: async () => "", deleted: () => {}, notice: () => {}, changed: () => {} })
|
|
await share.start()
|
|
try {
|
|
for (let i = 0; i < 300 && !heard.length; i++) await Bun.sleep(10)
|
|
expect(heard[0]).toMatchObject({ model: "deepseek/deepseek-flash", instance: true })
|
|
app.engine.effort = "high"
|
|
const r: any = await c.request("_lembas/configure", { sessionId: app.engine.sessionId, model: "deepseek/deepseek-flash" })
|
|
expect(r).toEqual({ model: "deepseek/deepseek-flash", effort: "high" })
|
|
} finally {
|
|
share.close()
|
|
hub.close()
|
|
await app.close()
|
|
}
|
|
})
|