LLeMbas CLI 1.0.0

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>

src/provider/sse.ts

@@ -0,0 +1,87 @@
+// Server-sent events → parsed JSON objects. Keep-alive comments and non-data lines are skipped;
+// a malformed frame is skipped rather than killing the reply (LLeMbas openai_client._stream_once).
+// Errors are surfaced in every shape seen in the wild — see the comments in `line()`.
+export async function* sseJson(body: ReadableStream<Uint8Array>): AsyncGenerator<{ event?: string; data: unknown }> {
+  const decoder = new TextDecoder()
+  let buf = ""
+  let event: string | undefined
+  let data: string[] = []
+  const out: { event?: string; data: unknown }[] = []
+
+  const dispatch = () => {
+    if (data.length === 0) return
+    const raw = data.join("\n")
+    data = []
+    const ev = event
+    event = undefined
+    if (raw === "[DONE]") return
+    try {
+      out.push({ event: ev, data: JSON.parse(raw) as unknown })
+    } catch {
+      // unparseable frame: skip
+    }
+  }
+
+  const line = (l: string) => {
+    if (l.endsWith("\r")) l = l.slice(0, -1)
+    if (l === "") return dispatch()
+    if (l.startsWith(":")) return
+    // llama.cpp (seen behind llama-swap) writes a mid-stream failure as a bare JSON line with no
+    // field name: `{"error":{"code":500,"message":"…"}}` — and as the stream's LAST line, with no
+    // newline after it. By the SSE rules it is a field called `{"error"` and would be ignored,
+    // silently ending the reply.
+    if (l.startsWith("{")) {
+      try {
+        const bare = JSON.parse(l) as unknown
+        if (bare && typeof bare === "object" && "error" in bare) {
+          dispatch()
+          out.push({ event: "error", data: bare })
+          return
+        }
+      } catch {}
+    }
+    const colon = l.indexOf(":")
+    const field = colon === -1 ? l : l.slice(0, colon)
+    let value = colon === -1 ? "" : l.slice(colon + 1)
+    if (value.startsWith(" ")) value = value.slice(1)
+    if (field === "data") {
+      // Some servers omit the blank line between events; a complete JSON frame on its own
+      // `data:` line is dispatched before the next one starts.
+      if (data.length > 0 && isJson(data.join("\n"))) dispatch()
+      data.push(value)
+    } else if (field === "event") event = value
+    else if (field === "error") {
+      // Some servers name the field `error:`. Same treatment as the bare JSON line.
+      let parsed: unknown = value
+      try {
+        parsed = JSON.parse(value)
+      } catch {}
+      dispatch()
+      out.push({ event: "error", data: parsed && typeof parsed === "object" && "error" in parsed ? parsed : { error: parsed } })
+    }
+  }
+
+  for await (const chunk of body) {
+    buf += decoder.decode(chunk, { stream: true })
+    let nl: number
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      line(buf.slice(0, nl))
+      buf = buf.slice(nl + 1)
+    }
+    yield* out.splice(0)
+  }
+  buf += decoder.decode()
+  // The last line may have no newline after it — and that is exactly where an error lands.
+  if (buf) line(buf)
+  dispatch()
+  yield* out.splice(0)
+}
+
+function isJson(s: string): boolean {
+  try {
+    JSON.parse(s)
+    return true
+  } catch {
+    return false
+  }
+}