@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/mistral-vibe.ts

@@ -0,0 +1,495 @@
+// Gateway connector for Mistral Vibe (the `vibe` CLI), checked against vibe 3.1.0 (`vibe --version`; the install in
+// ~/.cache/brain-wire/mistral-vibe, read only) and https://docs.mistral.ai/vibe/code/cli/configuration-reference.
+//
+// How Vibe reaches a custom endpoint (paths under site-packages/):
+//   - <VIBE_HOME or ~/.vibe>/config.toml (vibe/core/config/layers/user.py:26, vibe/core/paths/_vibe_home.py:13) holds a
+//     `[[providers]]` list (vibe/core/config/models.py:135-162: name, api_base, api_key_env_var, api_style "openai" by
+//     default, backend "generic" by default, extra_headers), a `[[models]]` list (models.py:520-524: name = the model id
+//     sent, provider, alias, display_name = what the model picker shows) and `active_model`, an alias
+//     (vibe/core/config/vibe_schema.py:559). Providers merge with Vibe's built-in ones by name and models by alias
+//     (vibe_schema.py:585-596), so adding one entry of each leaves the person's own and Vibe's defaults in place.
+//   - api_style "openai" posts to <api_base>/chat/completions
+//     (mistralai_vibe_local_harness/vibe/adapters/generic/_openai_chat.py:47) with `Authorization: Bearer <key>`
+//     (adapters/generic/_base.py:72-76) plus the provider's extra_headers verbatim (vibe/_runtime_config.py:551-552): so
+//     the gateway's OpenAI route, with the context-edit header.
+//   - The key: a provider names an environment variable (api_key_env_var); Vibe looks in its run's credentials, the
+//     environment, then the OS keyring (vibe/utils/api_keys.py:92-117). There is no key-file or key-command option. The
+//     app server loads <VIBE_HOME>/.env into the environment at start (vibe/app_server/stdio.py:199,
+//     vibe_schema.py:159-180; a variable already set in the shell wins), and Vibe's own setup stores keys there, owner-only
+//     (vibe/setup/auth/api_key_persistence.py:33-39). So the key is copied into that .env (holdsKey, 0600).
+//
+// config.toml is TOML that the core's "toml" format cannot edit (lists of tables), so this file brings its own
+// comment-keeping TOML editor (`tomlCodec`, also used by the Grok CLI connector): it changes only the entries it is given
+// and leaves every other line, comment and blank line as it was.
+import { join } from "node:path"
+import { type Codec, dirFromEnv, EDIT_HEADER, type Connector, type Json, modelName, readKey, routeUrl } from "../common.ts"
+
+// ---- a comment-keeping TOML editor ------------------------------------------------------------------------------------
+
+/**
+ * What a codec key names in the file:
+ *   key     one `key = value` line in a table ([] = the top of the file, before any [table])
+ *   table   a whole [a.b] table, with its sub-tables
+ *   entry   one [[array]] element, found by the first of `fields` it has (Vibe's models: alias, else name); with `mapForm`
+ *           a file that writes the list as [array.<match>] tables is edited in that form instead
+ */
+export type TomlTarget =
+  | { kind: "key"; table: string[]; key: string }
+  | { kind: "table"; path: string[] }
+  | { kind: "entry"; array: string; fields: string[]; match: string; mapForm?: boolean }
+
+/** A key as written: bare where it can be, quoted otherwise (also when it starts with a digit, which Bun's parser rejects). */
+const BARE = /^[A-Za-z_-][A-Za-z0-9_-]*$/
+export const tomlKey = (k: string) => (BARE.test(k) ? k : JSON.stringify(k))
+
+/** A value on one line: strings as basic strings (JSON's escapes are TOML's), tables as inline tables. */
+export function tomlValue(v: unknown): string {
+  if (typeof v === "string") return JSON.stringify(v).replace(/\u007f/g, "\\u007f")
+  if (typeof v === "boolean" || (typeof v === "number" && Number.isFinite(v))) return String(v)
+  if (Array.isArray(v)) return `[${v.map(tomlValue).join(", ")}]`
+  if (v && typeof v === "object") {
+    const e = Object.entries(v).filter(([, x]) => x !== undefined && x !== null)
+    return e.length ? `{ ${e.map(([k, x]) => `${tomlKey(k)} = ${tomlValue(x)}`).join(", ")} }` : "{}"
+  }
+  throw new Error("a value TOML cannot hold")
+}
+
+interface Row {
+  kind: "blank" | "comment" | "header" | "kv" | "more"
+  path?: string[]
+  array?: boolean
+  /** kv: where the value starts (after `=` and the spaces after it). */
+  at?: number
+}
+interface Doc {
+  lines: string[]
+  eol: string
+  rows: Row[]
+}
+
+/** A dotted key (bare, "basic" or 'literal' parts) starting at `at`, and where it ends. */
+function keyPath(s: string, at: number): { path: string[]; end: number } | undefined {
+  const path: string[] = []
+  let i = at
+  for (;;) {
+    while (s[i] === " " || s[i] === "\t") i++
+    if (s[i] === '"') {
+      let j = i + 1
+      while (j < s.length && s[j] !== '"') j += s[j] === "\\" ? 2 : 1
+      if (j >= s.length) return undefined
+      try {
+        path.push(JSON.parse(s.slice(i, j + 1)))
+      } catch {
+        return undefined
+      }
+      i = j + 1
+    } else if (s[i] === "'") {
+      const j = s.indexOf("'", i + 1)
+      if (j < 0) return undefined
+      path.push(s.slice(i + 1, j))
+      i = j + 1
+    } else {
+      const m = /^[A-Za-z0-9_-]+/.exec(s.slice(i))
+      if (!m) return undefined
+      path.push(m[0])
+      i += m[0].length
+    }
+    while (s[i] === " " || s[i] === "\t") i++
+    if (s[i] !== ".") return { path, end: i }
+    i++
+  }
+}
+
+/** Where a multi-line string that opened with `q` closes on this line (the index after it), or -1. */
+function closeAt(line: string, from: number, q: string): number {
+  for (let j = from; j < line.length; j++) {
+    if (q === '"""' && line[j] === "\\") {
+      j++
+      continue
+    }
+    if (line.startsWith(q, j)) {
+      let k = j + 3
+      for (let n = 0; n < 2 && line[k] === q[0]; n++) k++
+      return k
+    }
+  }
+  return -1
+}
+
+/**
+ * The file as lines, each classified. A line counts (header, key = value, comment, blank) only when it starts outside any
+ * multi-line string or bracket; the lines of a value that spans several are "more". undefined: something it cannot
+ * follow (an unclosed string or bracket, a line that is not TOML).
+ */
+function readDoc(text: string): Doc | undefined {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n"
+  const lines = text === "" ? [] : text.replace(/\r?\n$/, "").split(/\r?\n/)
+  const rows: Row[] = []
+  let ml: string | undefined
+  let depth = 0
+  for (const line of lines) {
+    const top = !ml && depth === 0
+    let i = 0
+    while (i < line.length) {
+      if (ml) {
+        const j = closeAt(line, i, ml)
+        if (j < 0) break
+        ml = undefined
+        i = j
+        continue
+      }
+      const c = line[i]!
+      if (c === "#") break
+      if (line.startsWith('"""', i) || line.startsWith("'''", i)) {
+        ml = line.slice(i, i + 3)
+        i += 3
+        continue
+      }
+      if (c === '"' || c === "'") {
+        let j = i + 1
+        while (j < line.length && line[j] !== c) j += c === '"' && line[j] === "\\" ? 2 : 1
+        if (j >= line.length) return undefined
+        i = j + 1
+        continue
+      }
+      if (c === "[" || c === "{") depth++
+      else if (c === "]" || c === "}") depth--
+      if (depth < 0) return undefined
+      i++
+    }
+    const t = line.trim()
+    if (!top) rows.push({ kind: "more" })
+    else if (!t) rows.push({ kind: "blank" })
+    else if (t.startsWith("#")) rows.push({ kind: "comment" })
+    else if (t.startsWith("[")) {
+      const m = /^\s*(\[\[?)/.exec(line)!
+      const array = m[1] === "[["
+      const k = keyPath(line, m[0].length)
+      const close = array ? "]]" : "]"
+      if (!k || !line.startsWith(close, k.end)) return undefined
+      const rest = line.slice(k.end + close.length).trim()
+      if (rest && !rest.startsWith("#")) return undefined
+      rows.push({ kind: "header", path: k.path, array })
+    } else {
+      const k = keyPath(line, 0)
+      if (!k || line[k.end] !== "=") return undefined
+      let at = k.end + 1
+      while (line[at] === " " || line[at] === "\t") at++
+      rows.push({ kind: "kv", path: k.path, at })
+    }
+  }
+  if (ml || depth) return undefined
+  return { lines, eol, rows }
+}
+
+const writeDoc = (lines: string[], eol: string) => (lines.length ? `${lines.join(eol)}${eol}` : "")
+const eq = (a: string[] | undefined, b: string[]) => !!a && a.length === b.length && a.every((x, i) => x === b[i])
+const startsWith = (a: string[] | undefined, b: string[]) => !!a && a.length > b.length && b.every((x, i) => x === a[i])
+const headersWhere = (d: Doc, ok: (r: Row) => boolean) => d.rows.flatMap((r, i) => (r.kind === "header" && ok(r) ? [i] : []))
+
+/** The first header after line `i` (lines.length when none); with `within`, headers of its sub-tables do not end it. */
+function sectionEnd(d: Doc, i: number, within?: string[]): number {
+  for (let j = i + 1; j < d.rows.length; j++) if (d.rows[j]!.kind === "header" && !(within && startsWith(d.rows[j]!.path, within))) return j
+  return d.rows.length
+}
+/** A section's own lines: blank lines and comments at its end belong to whatever follows. */
+function ownEnd(d: Doc, start: number, end: number): number {
+  while (end > start + 1 && (d.rows[end - 1]!.kind === "blank" || d.rows[end - 1]!.kind === "comment")) end--
+  return end
+}
+/** The end of the key = value starting at line i (a value may span lines). */
+function kvEnd(d: Doc, i: number, limit: number): number {
+  let j = i + 1
+  while (j < limit && d.rows[j]!.kind === "more") j++
+  return j
+}
+/** A removed block takes one blank line before it along (the one an added block was given). */
+const withBlankBefore = (d: Doc, from: number) => (from > 0 && d.rows[from - 1]!.kind === "blank" ? from - 1 : from)
+
+/** The ` # comment` after a value, outside any string, with the spaces before it. */
+function splitComment(s: string): { value: string; comment: string } {
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i]
+    if (c === '"' || c === "'") {
+      let j = i + 1
+      while (j < s.length && s[j] !== c) j += c === '"' && s[j] === "\\" ? 2 : 1
+      i = j
+    } else if (c === "#") {
+      let j = i
+      while (j > 0 && /[ \t]/.test(s[j - 1]!)) j--
+      return { value: s.slice(0, j), comment: s.slice(j).trimEnd() }
+    }
+  }
+  return { value: s.trimEnd(), comment: "" }
+}
+
+interface Splice {
+  from: number
+  to: number
+  lines: string[]
+}
+function apply(d: Doc, edits: Splice[]): string {
+  const lines = d.lines.slice()
+  for (const e of edits.sort((a, b) => b.from - a.from)) lines.splice(e.from, e.to - e.from, ...e.lines)
+  return writeDoc(lines, d.eol)
+}
+/** A new block at the end of the file, after a blank line. */
+const appendBlock = (d: Doc, block: string[]): Splice => ({ from: d.lines.length, to: d.lines.length, lines: d.lines.length ? ["", ...block] : block })
+const body = (v: Json) => Object.entries(v).flatMap(([k, x]) => (x === undefined || x === null ? [] : [`${tomlKey(k)} = ${tomlValue(x)}`]))
+
+function setKeyIn(d: Doc, table: string[], key: string, v: unknown): string {
+  let start = 0
+  let end = d.rows.findIndex((r) => r.kind === "header")
+  if (end < 0) end = d.rows.length
+  const h = table.length ? headersWhere(d, (r) => !r.array && eq(r.path, table))[0] : undefined
+  if (table.length) {
+    if (h === undefined) return v === undefined ? writeDoc(d.lines, d.eol) : apply(d, [appendBlock(d, [`[${table.map(tomlKey).join(".")}]`, `${tomlKey(key)} = ${tomlValue(v)}`])])
+    start = h + 1
+    end = sectionEnd(d, h)
+  }
+  let lastKv = -1
+  for (let i = start; i < end; i++) {
+    const r = d.rows[i]!
+    if (r.kind !== "kv") continue
+    const x = kvEnd(d, i, end)
+    if (!eq(r.path, [key])) {
+      lastKv = x
+      continue
+    }
+    if (v === undefined) {
+      // A table this leaves with nothing in it goes too (with the blank line before it): it was added with the key.
+      const emptied = h !== undefined && d.rows.slice(start, end).every((row, j) => start + j >= i && start + j < x ? true : row.kind === "blank")
+      return emptied ? apply(d, [{ from: withBlankBefore(d, h!), to: x, lines: [] }]) : apply(d, [{ from: i, to: x, lines: [] }])
+    }
+    const line = d.lines[i]!
+    const prefix = line.slice(0, r.at)
+    if (x > i + 1) return apply(d, [{ from: i, to: x, lines: [`${prefix}${tomlValue(v)}`] }])
+    // One line: its spacing, trailing comment and 'literal' quoting stay, so a later restore gives the line back as it was.
+    const { value, comment } = splitComment(line.slice(r.at))
+    const literal = value.startsWith("'") && !value.startsWith("'''") && typeof v === "string" && !/['\u0000-\u001f\u007f]/.test(v)
+    return apply(d, [{ from: i, to: x, lines: [`${prefix}${literal ? `'${v}'` : tomlValue(v)}${comment}`] }])
+  }
+  if (v === undefined) return writeDoc(d.lines, d.eol)
+  const at = lastKv >= 0 ? lastKv : table.length ? start : 0
+  return apply(d, [{ from: at, to: at, lines: [`${tomlKey(key)} = ${tomlValue(v)}`] }])
+}
+
+function setTable(d: Doc, path: string[], v: unknown): string {
+  const main = headersWhere(d, (r) => !r.array && eq(r.path, path))[0]
+  const subs = headersWhere(d, (r) => startsWith(r.path, path))
+  const edits: Splice[] = subs.map((h) => ({ from: withBlankBefore(d, h), to: ownEnd(d, h, sectionEnd(d, h)), lines: [] }))
+  const block = v === undefined ? [] : [`[${path.map(tomlKey).join(".")}]`, ...body(v as Json)]
+  if (main !== undefined) {
+    const to = ownEnd(d, main, sectionEnd(d, main))
+    edits.push(v === undefined ? { from: withBlankBefore(d, main), to, lines: [] } : { from: main, to, lines: block })
+  } else if (v !== undefined) edits.push(appendBlock(d, block))
+  return apply(d, edits)
+}
+
+function setEntry(d: Doc, parsed: Json, t: Extract<TomlTarget, { kind: "entry" }>, v: unknown): string {
+  const list = parsed[t.array]
+  if (list && typeof list === "object" && !Array.isArray(list)) return setTable(d, [t.array, t.match], v)
+  const heads = headersWhere(d, (r) => !!r.array && eq(r.path, [t.array]))
+  const idx = (Array.isArray(list) ? list : []).findIndex((e) => entryName(e, t.fields) === t.match)
+  const range = (h: number) => ({ from: h, to: ownEnd(d, h, sectionEnd(d, h, [t.array])) })
+  const block = v === undefined ? [] : [`[[${tomlKey(t.array)}]]`, ...body(v as Json)]
+  if (idx >= 0) {
+    const r = range(heads[idx]!)
+    return apply(d, [v === undefined ? { from: withBlankBefore(d, r.from), to: r.to, lines: [] } : { ...r, lines: block }])
+  }
+  if (v === undefined) return writeDoc(d.lines, d.eol)
+  // A new entry goes after the list's last one, or at the end of the file.
+  if (heads.length) {
+    const end = range(heads[heads.length - 1]!).to
+    return apply(d, [{ from: end, to: end, lines: ["", ...block] }])
+  }
+  return apply(d, [appendBlock(d, block)])
+}
+
+function entryName(e: unknown, fields: string[]): string | undefined {
+  if (!e || typeof e !== "object") return undefined
+  for (const f of fields) if (typeof (e as Json)[f] === "string") return (e as Json)[f]
+  return undefined
+}
+
+const parse = (text: string): Json => (text.trim() ? (Bun.TOML.parse(text) as Json) : {})
+const walk = (o: unknown, path: string[]): unknown => path.reduce<unknown>((cur, p) => (cur && typeof cur === "object" && !Array.isArray(cur) ? (cur as Json)[p] : undefined), o)
+
+function getTarget(parsed: Json, t: TomlTarget): unknown {
+  if (t.kind === "key") {
+    const tab = walk(parsed, t.table)
+    return tab && typeof tab === "object" && !Array.isArray(tab) ? (tab as Json)[t.key] : undefined
+  }
+  if (t.kind === "table") return walk(parsed, t.path)
+  const list = parsed[t.array]
+  if (Array.isArray(list)) return list.find((e) => entryName(e, t.fields) === t.match)
+  return t.mapForm && list && typeof list === "object" ? (list as Json)[t.match] : undefined
+}
+
+/** The parsed file without the target (and without a table or list the target alone made), for comparing the rest. */
+function without(parsed: Json, t: TomlTarget): Json {
+  const o = structuredClone(parsed)
+  const drop = (path: string[], last: string) => {
+    const parent = walk(o, path) as Json | undefined
+    if (!parent || typeof parent !== "object") return
+    delete parent[last]
+    for (let n = path.length; n > 0; n--) {
+      const here = walk(o, path.slice(0, n)) as Json
+      if (here && typeof here === "object" && !Array.isArray(here) && !Object.keys(here).length) delete (walk(o, path.slice(0, n - 1)) as Json)[path[n - 1]!]
+    }
+  }
+  if (t.kind === "key") drop(t.table, t.key)
+  else if (t.kind === "table") drop(t.path.slice(0, -1), t.path[t.path.length - 1]!)
+  else {
+    const list = o[t.array]
+    if (Array.isArray(list)) {
+      o[t.array] = list.filter((e) => entryName(e, t.fields) !== t.match)
+      if (!o[t.array].length) delete o[t.array]
+    } else drop([t.array], t.match)
+  }
+  return o
+}
+
+/** JSON with keys sorted, so two parses compare by content. */
+const canon = (v: unknown): string =>
+  Array.isArray(v) ? `[${v.map(canon).join(",")}]` : v && typeof v === "object" ? `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canon((v as Json)[k])}`).join(",")}}` : JSON.stringify(v) ?? "null"
+
+/** Why the file's way of writing the target's tables is not one these edits can keep valid (Bun's parser lets some through). */
+function layoutProblem(d: Doc, parsed: Json, t: TomlTarget): string | undefined {
+  const firstHeader = d.rows.findIndex((r) => r.kind === "header")
+  const pre = d.rows.slice(0, firstHeader < 0 ? d.rows.length : firstHeader)
+  const root = t.kind === "key" ? (t.table[0] ?? t.key) : t.kind === "table" ? t.path[0]! : t.array
+  const dotted = t.kind === "key" && !t.table.length ? pre.filter((r) => r.kind === "kv" && r.path![0] === root && r.path!.length > 1) : pre.filter((r) => r.kind === "kv" && r.path![0] === root)
+  if (dotted.length) return `${root} is written inline or with dotted keys`
+  if (t.kind === "key") {
+    if (!t.table.length) return pre.filter((r) => r.kind === "kv" && eq(r.path, [t.key])).length > 1 ? `${t.key} is set twice` : undefined
+    if (headersWhere(d, (r) => !r.array && eq(r.path, t.table)).length > 1) return `[${t.table.join(".")}] appears twice`
+    if (headersWhere(d, (r) => !!r.array && eq(r.path, t.table)).length) return `${t.table.join(".")} is a list of tables`
+    return undefined
+  }
+  if (t.kind === "table") {
+    const own = headersWhere(d, (r) => !r.array && eq(r.path, t.path))
+    if (own.length > 1) return `[${t.path.join(".")}] appears twice`
+    if (headersWhere(d, (r) => !!r.array && (eq(r.path, t.path) || startsWith(t.path, r.path!))).length) return `${t.path.join(".")} sits in a list of tables`
+    if (!own.length && walk(parsed, t.path) !== undefined) return `${t.path.join(".")} is written inline or with dotted keys`
+    return undefined
+  }
+  const list = parsed[t.array]
+  if (list && typeof list === "object" && !Array.isArray(list)) {
+    if (!t.mapForm) return `${t.array} is not a list`
+    if (headersWhere(d, (r) => !!r.array && eq(r.path, [t.array])).length) return `${t.array} is written two ways`
+    for (const h of headersWhere(d, (r) => !r.array && eq(r.path, [t.array]))) if (d.rows.slice(h + 1, sectionEnd(d, h)).some((r) => r.kind === "kv")) return `${t.array} entries are written with dotted keys`
+    for (const k of Object.keys(list)) if (headersWhere(d, (r) => !r.array && eq(r.path, [t.array, k])).length !== 1) return `${t.array}.${k} is not one [${t.array}.${k}] table`
+    return undefined
+  }
+  if (headersWhere(d, (r) => !r.array && eq(r.path, [t.array])).length) return `[${t.array}] is a table here, not a list`
+  if (headersWhere(d, (r) => !!r.array && eq(r.path, [t.array])).length !== (Array.isArray(list) ? list.length : 0)) return `${t.array} is not written as [[${t.array}]] tables`
+  return undefined
+}
+
+/**
+ * A comment-keeping TOML codec. `target` says what each key names; `samples` are the keys the connector edits, with a
+ * value like the one it writes: before anything changes, each is tried on the file (set, then removed), and a file where
+ * that would not give back the same content, or that writes those tables in a way these edits cannot keep valid, is refused.
+ */
+export function tomlCodec(target: (key: string) => TomlTarget, samples: Array<[string, unknown]>): Codec {
+  const codec: Codec = {
+    check(text) {
+      if (!text.trim()) return undefined
+      let parsed: Json
+      try {
+        parsed = parse(text)
+      } catch {
+        return "it is not valid TOML; left as it is"
+      }
+      const d = readDoc(text)
+      if (!d) return "brain cannot follow its layout (an unclosed string or bracket?); left as it is"
+      for (const [key, sample] of samples) {
+        const t = target(key)
+        const why = layoutProblem(d, parsed, t)
+        if (why) return `${why}, which brain does not edit; left as it is`
+        try {
+          const added = codec.set(text, key, sample)
+          const a = parse(added)
+          const removed = parse(codec.set(added, key, undefined))
+          const rest = canon(without(parsed, t))
+          if (canon(getTarget(a, t)) !== canon(sample) || canon(without(a, t)) !== rest || getTarget(removed, t) !== undefined || canon(without(removed, t)) !== rest) throw new Error("mismatch")
+        } catch {
+          return `brain could not edit ${key.replace(/\//g, ".")} there without touching the rest; left as it is`
+        }
+      }
+      return undefined
+    },
+    get(text, key) {
+      return getTarget(parse(text), target(key))
+    },
+    set(text, key, value) {
+      const d = readDoc(text)
+      if (!d) throw new Error("unreadable TOML layout")
+      const t = target(key)
+      if (t.kind === "key") return setKeyIn(d, t.table, t.key, value)
+      if (t.kind === "table") return setTable(d, t.path, value)
+      return setEntry(d, parse(text), t, value)
+    },
+  }
+  return codec
+}
+
+// ---- Mistral Vibe -------------------------------------------------------------------------------------------------------
+
+/** The provider and model entries brain adds (the alias is what `active_model` names; the picker shows display_name). */
+const PROVIDER = "100xprompt-gateway"
+const ALIAS = "100xprompt"
+/** The variable in <VIBE_HOME>/.env holding the key, named by the provider's api_key_env_var. */
+const KEY_VAR = "BRAIN_GATEWAY_KEY"
+
+const vibeHome = (home: string, env: Record<string, string | undefined>) => dirFromEnv(env, "VIBE_HOME", join(home, ".vibe"))
+
+const vibeTarget = (key: string): TomlTarget => {
+  const [head, ...rest] = key.split("/")
+  if (head === "providers" && rest.length) return { kind: "entry", array: "providers", fields: ["name"], match: rest.join("/") }
+  if (head === "models" && rest.length) return { kind: "entry", array: "models", fields: ["alias", "name"], match: rest.join("/"), mapForm: true }
+  return { kind: "key", table: [], key }
+}
+
+export const vibeToml = tomlCodec(vibeTarget, [
+  ["active_model", ALIAS],
+  [`providers/${PROVIDER}`, { name: PROVIDER, api_base: "https://gateway.example/flash/v1", api_key_env_var: KEY_VAR, extra_headers: { [EDIT_HEADER]: "on" } }],
+  [`models/${ALIAS}`, { name: "model-id", provider: PROVIDER, alias: ALIAS, display_name: "100xprompt Pro" }],
+])
+
+export const connectors: Connector[] = [
+  {
+    id: "mistral-vibe",
+    label: "Mistral Vibe",
+    file: (home, env) => join(vibeHome(home, env), "config.toml"),
+    probe: [".vibe"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: join(vibeHome(home, env), "config.toml"),
+        format: "custom",
+        codec: vibeToml,
+        values: {
+          active_model: ALIAS,
+          // Tables last: Vibe rewrites the file with tomli_w when it saves a setting, which puts them last, so the entry
+          // still reads back the same after that.
+          [`providers/${PROVIDER}`]: {
+            name: PROVIDER,
+            api_base: `${routeUrl(s)}/v1`,
+            api_key_env_var: KEY_VAR,
+            api_style: "openai",
+            backend: "generic",
+            ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
+          },
+          [`models/${ALIAS}`]: { name: s.model, provider: PROVIDER, alias: ALIAS, display_name: modelName(s.model) },
+        },
+      },
+      { path: join(vibeHome(home, env), ".env"), format: "dotenv", holdsKey: true, secretKeys: [KEY_VAR], values: { [KEY_VAR]: readKey(home) } },
+    ],
+    notes: [
+      "Mistral Vibe can read a key only from an environment variable, which it loads from ~/.vibe/.env at start: the key is kept there, so that file is now readable by you only (0600).",
+      "A project's own .vibe/config.toml that sets active_model still picks its model in that project; /model switches back and forth.",
+    ],
+  },
+]

package/src/gateway/connectors/muse.ts

@@ -0,0 +1,27 @@
+// Gateway connector for Muse Code (Meta's terminal coding agent, `muse`): NOT BUILT, deliberately. Checked against Muse Code
+// 0.2.1 (0.2.1-R1215.1, build b3170a534f), the version brain's session adapter and test/fixtures/native-corpus/muse were
+// captured from. Muse ships as a Linux x86_64 binary only and is not installed here (wire/drivers/f.ts), so nothing below
+// could be run; the evidence is Meta's docs and the one known working custom-endpoint setup.
+//
+// Why brain cannot point Muse at the 100xprompt gateway by editing a file:
+//   1. Muse only talks to Meta's own API shape. Its documented settings (~/.config/muse/settings.json, schema_version 1:
+//      https://dev.meta.ai/docs/muse-code/configuration) name no provider, endpoint or key option; sign-in is a Meta
+//      account or META_API_KEY (https://dev.meta.ai/docs/muse-code). The 0.2.1 binary enables only its `meta` and `echo`
+//      providers (muse-code-openrouter README, below).
+//   2. Its undocumented `endpoint_transport: {base_url, auth}` setting (and the `--base-url` flag) does move the `meta`
+//      provider, but before any inference Muse fetches Meta's proprietary model catalog (`/muse-code/models`), then sends
+//      Responses requests whose stream events must each carry `sequence_number`, for `meta/muse*` model ids listed in its
+//      `model_catalog`. The gateway serves none of that catalog (it answers /v1/models with 403 and has no /muse-code
+//      route) and serves gemini-* models. Source: muse-code-openrouter 0.3.2, the adapter session-migrate used to capture
+//      the fixture through a loopback (README "Why an adapter is needed"; src/muse_code_openrouter/install.py:240-253
+//      writes provider/model/endpoint_transport {base_url: http://127.0.0.1:<port>/v1, auth: "none"}/model_catalog;
+//      proxy.py:218-231 serves /muse-code/models and /responses, :200-203 adds sequence_number), and
+//      xhluca/session-migrate scripts/native-corpus/capture-muse.py (`muse exec --provider meta --base-url ...`).
+//   3. With `auth: "none"` (the only form that setup shows working) Muse sends no key at all; how Muse would send a key to a
+//      moved endpoint is undocumented, so the gateway key could not be delivered from a file either.
+// Reaching the gateway would take a local adapter process translating Muse's catalog and stream to the gateway (as
+// muse-code-openrouter does for OpenRouter), which is not a config edit; brain does not run one. Muse is still supported
+// for sessions (src/adapters/muse).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []