@100xprompt/brain 0.0.0-stage → 0.1.1

package/src/gateway/connectors/omp.ts

@@ -0,0 +1,279 @@
+// Gateway connector for Oh My Pi (can1357/oh-my-pi, `omp`, a fork of Pi). Checked against the source at tag v18.18.6 (the
+// latest release, 2026-11-09) and its docs; brain's session adapter was checked against 18.0.5. omp is not installed on this
+// machine (wire/drivers/f.ts), so there is no real-tool check for it.
+//
+// Where omp reads things: the agent dir ~/.omp/agent, or ~/.omp/profiles/<name>/agent for OMP_PROFILE (PI_PROFILE as the
+// fallback), or $PI_CODING_AGENT_DIR for the default profile; PI_CONFIG_DIR renames .omp (packages/utils/src/dirs.ts:29-33,
+// 84-135, 331-339, 367-374).
+//   - models.yml (else models.yaml) `providers.<id>`: baseUrl, api ("openai-completions", ...), apiKey, headers, compat,
+//     models[{id, name, input}] (docs/models.md "Config file location", "Provider-level fields";
+//     packages/coding-agent/src/config/models-config.ts:44-88 requires baseUrl and apiKey for a provider with models).
+//     Without either YAML file a legacy models.json is migrated to models.yml on the next start
+//     (src/config/config-file.ts:30-56, 173-179): brain writing models.yml first would make omp skip that migration and drop
+//     the person's providers, so that case is refused until omp has run once.
+//   - apiKey and header values starting with "!" are shell commands whose trimmed stdout is used, at request time
+//     (src/config/resolve-config-value.ts:22-24, 104-108; docs/models.md "Command-resolved secrets"): the key is read from
+//     brain's key file with `!cat '<key file>'`, never copied. Plain header values are literals (or an env var of that name).
+//   - config.yml (else config.yaml) `modelRoles.default: <provider>/<model>` is the main session model; unset smol/slow
+//     follow it (docs/models.md "Role aliases and settings", "Initial model selection priority";
+//     src/config/settings.ts:2228-2237, 2658-2670; MAIN_CONFIG_FILENAMES in utils/src/dirs.ts:32). Without either file omp
+//     first migrates a legacy settings.json (settings.ts:2885-2945), so that case is refused the same way.
+// The request is OpenAI Chat Completions on <route>/v1 with Authorization: Bearer (the provider's apiKey), plus
+// `x-100x-context-edit: on`. Both YAML files are edited by the codec below: one entry under one top-level mapping, every other
+// line kept as it was, so disconnect gives the exact bytes back.
+import { existsSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, routeUrl, yamlTopLevel } from "../common.ts"
+import { CHAT_COMPAT, keyCommand, PROVIDER_ID } from "./pi.ts"
+
+// ---- YAML: one entry of one top-level mapping, every other line as it was -----------------------------------------------
+
+const isObj = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v)
+const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+const quietLine = (l: string) => !l.trim() || /^\s*#/.test(l)
+const indentOf = (l: string) => /^ */.exec(l)![0].length
+const keyLine = (k: string, indent: number) => new RegExp(`^ {${indent}}(?:${esc(k)}|"${esc(k)}"|'${esc(k)}')[ \\t]*:(?:[ \\t]|$)`)
+
+/**
+ * A scalar as YAML: a plain word when YAML reads it back as the same string (and an older YAML would not read it as a
+ * boolean, as it would `on`), otherwise JSON (valid YAML).
+ */
+function scalar(v: unknown): string {
+  if (typeof v === "string" && /^[A-Za-z0-9_./@-][A-Za-z0-9_./:@+=-]*$/.test(v) && !/^(y|n|yes|no|on|off)$/i.test(v)) {
+    try {
+      if ((Bun.YAML.parse(`k: ${v}`) as Json).k === v) return v
+    } catch {}
+  }
+  return JSON.stringify(v)
+}
+const leaf = (v: unknown) => (isObj(v) ? "{}" : Array.isArray(v) ? "[]" : scalar(v))
+
+/** `key: value` in block style at `indent`, nested one `unit` deeper. */
+function block(key: string, v: unknown, indent: string, unit: string): string[] {
+  const head = `${indent}${scalar(key)}:`
+  if (isObj(v) && Object.keys(v).length) return [head, ...Object.entries(v).flatMap(([k, x]) => block(k, x, indent + unit, unit))]
+  if (Array.isArray(v) && v.length) return [head, ...v.flatMap((x) => item(x, indent + unit, unit))]
+  return [`${head} ${leaf(v)}`]
+}
+function item(x: unknown, indent: string, unit: string): string[] {
+  if (isObj(x) && Object.keys(x).length) {
+    const lines = Object.entries(x).flatMap(([k, y]) => block(k, y, `${indent}  `, unit))
+    return [`${indent}- ${lines[0]!.slice(indent.length + 2)}`, ...lines.slice(1)]
+  }
+  return [`${indent}- ${Array.isArray(x) && x.length ? JSON.stringify(x) : leaf(x)}`]
+}
+
+/** The ` # comment` ending a one-line entry (a # after a space, outside quotes), with the spaces before it. */
+function trailing(line: string): string {
+  let quote: string | undefined
+  for (let i = line.indexOf(":") + 1; i > 0 && i < line.length; i++) {
+    const c = line[i]!
+    if (quote) {
+      if (c === "\\" && quote === '"') i++
+      else if (c === quote) quote = undefined
+    } else if (c === '"' || c === "'") quote = c
+    else if (c === "#" && /[ \t]/.test(line[i - 1]!)) {
+      let j = i
+      while (j > 0 && /[ \t]/.test(line[j - 1]!)) j--
+      return line.slice(j).trimEnd()
+    }
+  }
+  return ""
+}
+
+interface Lines {
+  lines: string[]
+  /** Whether the text ended with a newline (kept as it was). */
+  nl: boolean
+}
+const toLines = (t: string): Lines => ({ lines: t ? t.replace(/\n$/, "").split("\n") : [], nl: !t || t.endsWith("\n") })
+const fromLines = (d: Lines) => (d.lines.length ? `${d.lines.join("\n")}${d.nl ? "\n" : ""}` : "")
+
+/** The top-level `parent:` line and the end (exclusive) of its last indented line, or undefined. */
+function parentAt(lines: string[], parent: string): { at: number; end: number } | undefined {
+  const re = keyLine(parent, 0)
+  const at = lines.findIndex((l) => re.test(l))
+  if (at < 0) return undefined
+  let end = at + 1
+  for (let j = at + 1; j < lines.length; j++) {
+    const l = lines[j]!
+    if (quietLine(l)) continue
+    if (!/^[ \t]/.test(l)) break
+    end = j + 1
+  }
+  return { at, end }
+}
+
+/** What follows `parent:` on its line, without a trailing comment. */
+const parentValue = (line: string, parent: string) => {
+  const m = keyLine(parent, 0).exec(line)!
+  const rest = line.slice(m[0].length)
+  const c = trailing(line)
+  return (c ? rest.slice(0, rest.length - c.length) : rest).trim()
+}
+
+/** The child entries' indentation and the child `key`'s lines [at, end) inside the parent's block (at -1: not there). */
+function childAt(lines: string[], p: { at: number; end: number }, key: string): { indent?: number; at: number; end: number } {
+  const content: number[] = []
+  for (let j = p.at + 1; j < p.end; j++) if (!quietLine(lines[j]!)) content.push(j)
+  if (!content.length) return { at: -1, end: -1 }
+  const indent = indentOf(lines[content[0]!]!)
+  const re = keyLine(key, indent)
+  const at = content.find((j) => re.test(lines[j]!)) ?? -1
+  if (at < 0) return { indent, at, end: -1 }
+  let end = at + 1
+  for (let j = at + 1; j < p.end; j++) {
+    const l = lines[j]!
+    if (quietLine(l)) continue
+    if (indentOf(l) > indent || (indentOf(l) === indent && /^ *- /.test(l))) end = j + 1
+    else break
+  }
+  return { indent, at, end }
+}
+
+/** The indentation step: the smallest indentation of any indented line, else two spaces. */
+function unitOf(lines: string[]): number {
+  const ins = lines.filter((l) => !quietLine(l) && /^ +\S/.test(l)).map(indentOf)
+  return ins.length ? Math.min(...ins) : 2
+}
+
+/**
+ * A Codec for one entry of one top-level mapping of a YAML file: keys are `<parent>/<child>` (providers/brain-gateway,
+ * modelRoles/default). The entry is written in block style in the file's own indentation; a parent that is not there is
+ * added at the end, and removed again when the removal leaves it empty. A parent written as a one-line {...} mapping is
+ * rewritten as JSON on that line (`{}` comes back as `{}`). `beforeFirstWrite` may refuse a missing or empty file.
+ */
+export function yamlEntry(parent: string, beforeFirstWrite?: () => string | undefined): Codec {
+  const split = (key: string) => {
+    const [p, ...rest] = key.split("/")
+    if (p !== parent || rest.length !== 1) throw new Error(`${key}: this file's editor only handles ${parent}/<name>`)
+    return rest[0]!
+  }
+  return {
+    check(text) {
+      if (!text.trim()) return beforeFirstWrite?.()
+      const base = yamlTopLevel.check!(text)
+      if (base) return base
+      if (text.includes("\r")) return "it has Windows (CRLF) line endings; left as it is"
+      const { lines } = toLines(text)
+      const first = lines.find((l) => !quietLine(l) && !/^(---|%)/.test(l))
+      if (first && /^[{[]/.test(first.trim())) return "it is written as one {...} mapping; left as it is"
+      const re = keyLine(parent, 0)
+      const ats = lines.flatMap((l, j) => (re.test(l) ? [j] : []))
+      if (ats.length > 1) return `it names ${parent} more than once; left as it is`
+      const doc = (Bun.YAML.parse(text) ?? {}) as Json
+      if (!ats.length) return Object.hasOwn(doc, parent) ? `its ${parent} entry is written in a way brain does not edit; left as it is` : undefined
+      const v = parentValue(lines[ats[0]!]!, parent)
+      const value = doc[parent]
+      if (v === "") {
+        if (value !== null && value !== undefined && !isObj(value)) return `its ${parent} is not a mapping; left as it is`
+        const p = parentAt(lines, parent)!
+        const content = lines.slice(p.at + 1, p.end).filter((l) => !quietLine(l))
+        if (content.length && (/^ *- /.test(content[0]!) || content.some((l) => indentOf(l) < indentOf(content[0]!)))) return `its ${parent} block is indented in a way brain does not edit; left as it is`
+        return undefined
+      }
+      if (!/^\{.*\}$/.test(v) || !isObj(value)) return `its ${parent} is not a plain mapping; left as it is`
+      return undefined
+    },
+    get(text, key) {
+      const child = split(key)
+      if (!text.trim()) return undefined
+      const doc = Bun.YAML.parse(text) as Json | null
+      const p = isObj(doc) ? doc[parent] : undefined
+      return isObj(p) && Object.hasOwn(p, child) ? p[child] : undefined
+    },
+    set(text, key, value) {
+      const child = split(key)
+      const d = toLines(text)
+      const { lines } = d
+      const unit = " ".repeat(unitOf(lines))
+      const p = parentAt(lines, parent)
+      if (!p) {
+        if (value === undefined) return text
+        lines.push(`${parent}:`, ...block(child, value, unit, unit))
+        return fromLines(d)
+      }
+      const v = parentValue(lines[p.at]!, parent)
+      if (v !== "") {
+        // A one-line {...} mapping: change it as data, write it back as JSON on the same line.
+        const map = { ...((Bun.YAML.parse(`k: ${v}`) as Json).k as Json) }
+        if (value === undefined) delete map[child]
+        else map[child] = value
+        const head = keyLine(parent, 0).exec(lines[p.at]!)![0].replace(/[ \t]*$/, "")
+        lines[p.at] = `${head} ${Object.keys(map).length ? JSON.stringify(map) : "{}"}${trailing(lines[p.at]!)}`
+        return fromLines(d)
+      }
+      const c = childAt(lines, p, child)
+      const indent = " ".repeat(c.indent ?? unit.length)
+      if (c.at < 0) {
+        if (value === undefined) return text
+        lines.splice(p.end, 0, ...block(child, value, indent, unit))
+        return fromLines(d)
+      }
+      if (value !== undefined) {
+        const repl = block(child, value, indent, unit)
+        // A one-line entry keeps its trailing comment, so a later restore gives the line back as it was.
+        if (c.end === c.at + 1 && repl.length === 1) repl[0] += trailing(lines[c.at]!)
+        lines.splice(c.at, c.end - c.at, ...repl)
+        return fromLines(d)
+      }
+      lines.splice(c.at, c.end - c.at)
+      // A parent this left with nothing under it (not even a comment) goes too: connect added it.
+      const q = parentAt(lines, parent)!
+      const next = lines[q.at + 1]
+      if (q.end === q.at + 1 && !trailing(lines[q.at]!) && (next === undefined || !/^[ \t]+#/.test(next))) lines.splice(q.at, 1)
+      return fromLines(d)
+    },
+  }
+}
+
+// ---- Oh My Pi -----------------------------------------------------------------------------------------------------------
+
+function agentDir(home: string, env: Env): string {
+  const root = join(home, env.PI_CONFIG_DIR?.trim() || ".omp")
+  const profile = (env.OMP_PROFILE !== undefined ? env.OMP_PROFILE : env.PI_PROFILE)?.trim()
+  if (profile && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(profile)) return join(root, "profiles", profile, "agent")
+  return dirFromEnv(env, "PI_CODING_AGENT_DIR", join(root, "agent"))
+}
+
+/** <dir>/<name>.yml, or <name>.yaml when only that one exists (omp reads the .yml first). */
+const yamlFile = (dir: string, name: string) => (!existsSync(join(dir, `${name}.yml`)) && existsSync(join(dir, `${name}.yaml`)) ? join(dir, `${name}.yaml`) : join(dir, `${name}.yml`))
+
+/** Refuses writing a first YAML file while the legacy JSON one omp would migrate from is still there. */
+const unmigrated = (path: string, legacy: string) => () =>
+  existsSync(join(dirname(path), legacy)) ? `Oh My Pi has not moved its ${legacy} to YAML yet (it does on its next start); run omp once, then connect` : undefined
+
+export function ompProvider(home: string, s: GatewaySettings): Json {
+  return {
+    baseUrl: `${routeUrl(s)}/v1`,
+    api: "openai-completions",
+    apiKey: keyCommand(home),
+    ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+    compat: CHAT_COMPAT,
+    models: [{ id: s.model, name: modelName(s.model), input: ["text", "image"] }],
+  }
+}
+
+const omp: Connector = {
+  id: "omp",
+  label: "Oh My Pi",
+  file: (home, env) => yamlFile(agentDir(home, env), "models"),
+  // The agent dir (the main file's folder) is what omp's first run creates.
+  probe: [],
+  authHeader: "authorization",
+  edits: (home, s, env) => {
+    const dir = agentDir(home, env)
+    const models = yamlFile(dir, "models")
+    const config = yamlFile(dir, "config")
+    return [
+      { path: models, format: "custom", codec: yamlEntry("providers", unmigrated(models, "models.json")), values: { [`providers/${PROVIDER_ID}`]: ompProvider(home, s) } },
+      { path: config, format: "custom", codec: yamlEntry("modelRoles", unmigrated(config, "settings.json")), values: { "modelRoles/default": `${PROVIDER_ID}/${s.model}` } },
+    ]
+  },
+  notes: [
+    `Oh My Pi's default model role is now the "${PROVIDER_ID}" provider in models.yml; it reads the key from the brain's key file when it sends a request (apiKey "!cat <key file>").`,
+    "A --model flag, a project's .omp/config.yml modelRoles, or an enabledModels list that leaves this model out still take precedence; smol and slow roles you set yourself keep their own models.",
+  ],
+}
+
+export const connectors: Connector[] = [omp]

package/src/gateway/connectors/openhands.ts

@@ -0,0 +1,296 @@
+// Gateway connector for the OpenHands CLI (`openhands`, PyPI package openhands 1.16.0 with openhands-sdk 1.21.0, checked
+// in the installed copy at ~/.cache/brain-wire/openhands/venv, site-packages below):
+//
+//   - The CLI keeps its whole agent spec, LLM included, in <persistence dir>/agent_settings.json, the persistence dir being
+//     $OPENHANDS_PERSISTENCE_DIR or ~/.openhands (openhands_cli/locations.py:4-11,34). It loads it with
+//     Agent.model_validate_json at every start (openhands_cli/stores/agent_store.py:262-284) and writes it back only when
+//     the person saves settings (agent_store.py:473-475, tui/modals/settings/utils.py:267). It is pydantic's compact JSON
+//     (no spaces, floats as 8.0), so it is edited here in place (the codec below) and comes back byte for byte.
+//   - The LLM is `llm` (and the summarising condenser's own `condenser.llm`, which OpenHands' settings screen sets to the
+//     same model: tui/modals/settings/utils.py:216-235). Its fields (openhands/sdk/llm/llm.py:167-300): `model` (a LiteLLM
+//     id: "openai/<id>" sends OpenAI Chat Completions to `base_url` + /chat/completions with `Authorization: Bearer
+//     <api_key>`; llm.py:1161-1180), `base_url`, `api_key`, and `extra_headers`, forwarded on every chat and Responses call
+//     (openhands/sdk/llm/options/chat_options.py:31-33, responses_options.py:30-32): the context-edit header goes there.
+//     "litellm_proxy/<id>" is not used: it makes the SDK ask <base_url>/v1/model/info first (sdk/llm/utils/model_info.py:
+//     15-67), which the gateway does not serve.
+//   - The key: `api_key` is a plain string in that file (written with expose_secrets: agent_store.py:474); there is no
+//     key-file or command option (sdk/utils/pydantic_secrets.py:65-90), and the only env route (LLM_API_KEY) needs the
+//     --override-with-envs flag on every run (agent_store.py:131-237). So the key is copied in: the file is made 0600
+//     and the key is replaced on a new sign-in.
+//   - Besides model, base_url, api_key and extra_headers, the values OpenHands derives from the previous model are reset,
+//     as OpenHands' own settings screen does when the model changes (it builds a fresh LLM: tui/modals/settings/utils.py:
+//     186-211): max_input_tokens and max_output_tokens (null: the SDK looks them up again; a previous model's 64k or 128k
+//     output cap would be sent as max_completion_tokens), model_canonical_name (it overrides capability lookups, e.g. a
+//     "gpt-5" name would switch to the Responses API: sdk/llm/utils/model_features.py:159-201) and litellm_extra_body
+//     (routing metadata for the previous endpoint; chat_options.py:83-85 sends it as extra_body). All of them come back
+//     on disconnect.
+//   - OpenHands has no named providers or model list (no profile is used by the CLI), so the LLM entry itself is switched.
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, type Json, readKey, routeUrl } from "../common.ts"
+
+// ---- JSON edited in place ------------------------------------------------------------------------------------------------
+
+interface Member {
+  key: string
+  keyStart: number
+  keyEnd: number
+  valueStart: number
+  valueEnd: number
+  value: Node
+}
+type Node = { kind: "object"; start: number; end: number; members: Member[] } | { kind: "other"; start: number; end: number }
+
+/** The spans of a JSON text (already known to be valid JSON): every object's members with where their key and value are. */
+function parseSpans(text: string): Node {
+  let i = 0
+  const ws = () => {
+    while (i < text.length && /[ \t\r\n]/.test(text[i]!)) i++
+  }
+  const str = () => {
+    i++ // opening quote
+    while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1
+    i++ // closing quote
+  }
+  const value = (): Node => {
+    ws()
+    const start = i
+    const c = text[i]
+    if (c === "{") {
+      i++
+      const members: Member[] = []
+      ws()
+      if (text[i] === "}") {
+        i++
+        return { kind: "object", start, end: i, members }
+      }
+      for (;;) {
+        ws()
+        const keyStart = i
+        str()
+        const keyEnd = i
+        ws()
+        i++ // :
+        ws()
+        const valueStart = i
+        const v = value()
+        members.push({ key: JSON.parse(text.slice(keyStart, keyEnd)), keyStart, keyEnd, valueStart, valueEnd: i, value: v })
+        ws()
+        if (text[i] === ",") {
+          i++
+          continue
+        }
+        i++ // }
+        return { kind: "object", start, end: i, members }
+      }
+    }
+    if (c === "[") {
+      i++
+      ws()
+      if (text[i] === "]") {
+        i++
+        return { kind: "other", start, end: i }
+      }
+      for (;;) {
+        value()
+        ws()
+        if (text[i++] === "]") return { kind: "other", start, end: i }
+      }
+    }
+    if (c === '"') {
+      str()
+      return { kind: "other", start, end: i }
+    }
+    while (i < text.length && !/[,}\]\s]/.test(text[i]!)) i++
+    return { kind: "other", start, end: i }
+  }
+  return value()
+}
+
+/** How the file writes JSON, read off its first object with members: compact (pydantic, JSON.stringify) or indented. */
+interface Style {
+  colon: string
+  comma: string
+  /** Indent unit of an indented file; undefined for a one-line file. */
+  unit?: string
+}
+
+function styleOf(text: string, root: Node): Style {
+  const multiline = /\n\s*\S/.test(text.trim())
+  let colon: string | undefined
+  let comma: string | undefined
+  let unit: string | undefined
+  const walk = (n: Node, indent: string) => {
+    if (n.kind !== "object") return
+    const [a, b] = n.members
+    if (a && colon === undefined) colon = text.slice(a.keyEnd, a.valueStart)
+    if (a && b && comma === undefined && !text.slice(a.valueEnd, b.keyStart).includes("\n")) comma = text.slice(a.valueEnd, b.keyStart)
+    if (a && unit === undefined && multiline) {
+      const own = lineIndent(text, a.keyStart)
+      if (own.length > indent.length) unit = own.slice(indent.length)
+    }
+    for (const m of n.members) walk(m.value, lineIndent(text, m.keyStart))
+  }
+  walk(root, "")
+  return { colon: colon ?? (multiline ? ": " : ":"), comma: comma ?? ",", ...(multiline ? { unit: unit ?? "  " } : {}) }
+}
+
+/** The spaces before the first non-space character of the line holding `at`. */
+function lineIndent(text: string, at: number): string {
+  const start = text.lastIndexOf("\n", at - 1) + 1
+  return /^[ \t]*/.exec(text.slice(start))![0]
+}
+
+/** A value written in the file's own style; `indent` is the indent of the line it starts on. */
+function serialize(v: unknown, st: Style, indent: string): string {
+  if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null"
+  const arr = Array.isArray(v)
+  const entries: Array<[string | undefined, unknown]> = arr ? (v as unknown[]).map((x) => [undefined, x]) : Object.entries(v as Json)
+  const [open, close] = arr ? ["[", "]"] : ["{", "}"]
+  if (!entries.length) return open + close
+  const item = ([k, x]: [string | undefined, unknown], at: string) => (k === undefined ? "" : JSON.stringify(k) + st.colon) + serialize(x, st, at)
+  if (st.unit === undefined) return open + entries.map((e) => item(e, indent)).join(st.comma) + close
+  const inner = indent + st.unit
+  return `${open}\n${entries.map((e) => inner + item(e, inner)).join(",\n")}\n${indent}${close}`
+}
+
+/** `value` under the path `parts` (objects created on the way). */
+const nest = (parts: string[], value: unknown): unknown => parts.reduceRight((v, p) => ({ [p]: v }), value)
+
+/** The text with member `m` of object `o` removed, together with the comma and spaces that joined it to its neighbour. */
+function removeMember(text: string, o: Extract<Node, { kind: "object" }>, m: Member): string {
+  const i = o.members.indexOf(m)
+  if (o.members.length === 1) return text.slice(0, o.start + 1) + text.slice(o.end - 1)
+  if (i === o.members.length - 1) return text.slice(0, o.members[i - 1]!.valueEnd) + text.slice(m.valueEnd)
+  return text.slice(0, m.keyStart) + text.slice(o.members[i + 1]!.keyStart)
+}
+
+/** The text with `"key": value` added as the last member of object `o`. */
+function addMember(text: string, o: Extract<Node, { kind: "object" }>, key: string, value: unknown, st: Style): string {
+  const last = o.members[o.members.length - 1]
+  const parentIndent = lineIndent(text, o.start)
+  const indent = last ? lineIndent(text, last.keyStart) : parentIndent + (st.unit ?? "")
+  const member = `${JSON.stringify(key)}${st.colon}${serialize(value, st, indent)}`
+  if (last) {
+    const multiline = text.slice(o.start, o.members[0]!.keyStart).includes("\n")
+    const sep = multiline ? `,\n${indent}` : st.comma
+    return text.slice(0, last.valueEnd) + sep + member + text.slice(last.valueEnd)
+  }
+  const body = st.unit === undefined ? member : `\n${indent}${member}\n${parentIndent}`
+  return text.slice(0, o.start + 1) + body + text.slice(o.end - 1)
+}
+
+/**
+ * Plain JSON (a JSON object) with keys as "/" paths, like the core's json format, but edited in place: a value is
+ * replaced where it stands, a new key is added after the last member of its object in the file's own spacing, and a
+ * removed key takes back exactly what was added. Everything else keeps its bytes (pydantic's compact JSON with its 8.0
+ * floats stays as it is). Objects a removal leaves empty are dropped, as the core does (never the root).
+ */
+export const jsonInPlace: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    try {
+      const v = JSON.parse(text)
+      if (!v || typeof v !== "object" || Array.isArray(v)) return "it is not a JSON object; left as it is"
+    } catch {
+      return "it is not plain JSON; left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    if (!text.trim()) return undefined
+    let cur: unknown = JSON.parse(text)
+    for (const p of key.split("/")) {
+      if (!cur || typeof cur !== "object" || Array.isArray(cur) || !(p in (cur as Json))) return undefined
+      cur = (cur as Json)[p]
+    }
+    return cur
+  },
+  set(text, key, value) {
+    return setPath(text, key.split("/"), value)
+  },
+}
+
+function setPath(text: string, parts: string[], value: unknown): string {
+  // A new (or empty) file is started as an indented object, as the core writes JSON.
+  const src = text.trim() ? text : "{}\n"
+  const root = parseSpans(src)
+  if (root.kind !== "object") throw new Error("not a JSON object")
+  const st: Style = text.trim() ? styleOf(src, root) : { colon: ": ", comma: ",", unit: "  " }
+  let o = root
+  for (let d = 0; d < parts.length; d++) {
+    // The last of duplicate keys wins, as in JSON.parse.
+    const m = o.members.filter((x) => x.key === parts[d]).pop()
+    const last = d === parts.length - 1
+    if (!m) return value === undefined ? text : addMember(src, o, parts[d]!, nest(parts.slice(d + 1), value), st)
+    if (!last && m.value.kind === "object") {
+      o = m.value
+      continue
+    }
+    if (value === undefined) {
+      if (!last) return text
+      const out = removeMember(src, o, m)
+      // The object this left empty goes too (spans are read again from the new text), never the root.
+      return o.members.length === 1 && d > 0 ? setPath(out, parts.slice(0, d), undefined) : out
+    }
+    const v = last ? value : nest(parts.slice(d + 1), value)
+    return src.slice(0, m.valueStart) + serialize(v, st, lineIndent(src, m.keyStart)) + src.slice(m.valueEnd)
+  }
+  return text
+}
+
+// ---- the connector -----------------------------------------------------------------------------------------------------
+
+const persistenceDir = (home: string, env: Env) => dirFromEnv(env, "OPENHANDS_PERSISTENCE_DIR", join(home, ".openhands"))
+const settingsFile = (home: string, env: Env) => join(persistenceDir(home, env), "agent_settings.json")
+
+/** Whether the agent spec has a summarising condenser with its own LLM (then that LLM is pointed at the gateway too). */
+function hasCondenserLlm(path: string): boolean {
+  try {
+    const c = JSON.parse(readFileSync(path, "utf8"))?.condenser?.llm
+    return !!c && typeof c === "object" && !Array.isArray(c)
+  } catch {
+    return false
+  }
+}
+
+/** The values one OpenHands LLM entry (`llm` or `condenser/llm`) gets. */
+const llmValues = (prefix: string, home: string, s: GatewaySettings): Record<string, unknown> => ({
+  [`${prefix}/model`]: `openai/${s.model}`,
+  [`${prefix}/base_url`]: `${routeUrl(s)}/v1`,
+  [`${prefix}/api_key`]: readKey(home),
+  [`${prefix}/extra_headers`]: s.contextEdit ? { [EDIT_HEADER]: "on" } : null,
+  [`${prefix}/model_canonical_name`]: null,
+  [`${prefix}/max_input_tokens`]: null,
+  [`${prefix}/max_output_tokens`]: null,
+  [`${prefix}/litellm_extra_body`]: {},
+})
+
+export const connectors: Connector[] = [
+  {
+    id: "openhands",
+    label: "OpenHands",
+    file: settingsFile,
+    probe: [".openhands"],
+    authHeader: "authorization",
+    edits: (home, s, env) => {
+      const path = settingsFile(home, env)
+      const prefixes = ["llm", ...(hasCondenserLlm(path) ? ["condenser/llm"] : [])]
+      return [
+        {
+          path,
+          format: "custom",
+          codec: jsonInPlace,
+          holdsKey: true,
+          secretKeys: prefixes.map((p) => `${p}/api_key`),
+          values: Object.assign({}, ...prefixes.map((p) => llmValues(p, home, s))),
+        },
+      ]
+    },
+    notes: [
+      "OpenHands keeps the key in its agent_settings.json (it has no key-file option), so the file is now readable by you only (0600); a new sign-in replaces the key there.",
+      "Its agent and memory-condenser LLM now use the gateway's model over OpenAI Chat Completions; the model limits OpenHands had stored for your previous model are cleared so it looks them up again.",
+      "Run without --override-with-envs (or without LLM_API_KEY, LLM_BASE_URL and LLM_MODEL set): those override this file. Changing the LLM in OpenHands' settings screen replaces these values, and disconnect then leaves your choice alone.",
+    ],
+  },
+]

package/src/gateway/connectors/pearai.ts

@@ -0,0 +1,52 @@
+// Gateway connector for PearAI's chat ("PearAI Chat"), a fork of an older Continue. Checked against its source,
+// trypear/pearai-submodule at main 51eceef (2026-06-18; extensions/vscode/package.json: "PearAI" 2.0.0). PearAI is not
+// installed on this machine and is not in ~/.cache/brain-wire, so there is no real-tool check; the file format is the one
+// Continue's own config.json loader reads too, which test/gateway-connectors/pearai.test.ts and continue.test.ts exercise.
+//
+// Where PearAI reads its settings (core/util/paths.ts):
+//   ~/.pearai                 CONTINUE_GLOBAL_DIR ?? ~/.pearai (paths.ts:10-12). brain does not follow CONTINUE_GLOBAL_DIR
+//                             here: that variable is Continue's, and a person who sets it means Continue's folder.
+//   ~/.pearai/config.json     created on first start with `"models": []` (getConfigJsonPath, config/default.ts defaultConfig),
+//                             read as JSON with comments (comment-json) by core/config/load.ts resolveSerializedConfig (:71-96).
+//   ~/.pearai/.env            getContinueDotEnv (paths.ts:289-295). resolveSerializedConfig replaces every "NAME" string in
+//                             config.json with NAME's value from the process environment or this file, for each NAME listed
+//                             in the top-level "env" array. There is no other way to give a key (no file or command).
+// A model is an entry of "models": title, provider "openai", model, apiBase, apiKey, contextLength, requestOptions.headers.
+// Provider openai posts Chat Completions to new URL("chat/completions", apiBase) (core/llm/llms/OpenAI.ts:337-352, :425)
+// with Authorization: Bearer <apiKey> (:314-320); apiBase is given a trailing "/" first (core/llm/index.ts:184-186), and
+// requestOptions.headers go with every request (core/llm/index.ts:301-304, core/util/fetchWithOptions.ts:74-80). The
+// Responses API is used only against api.openai.com (OpenAI.ts usesResponsesApi).
+// The model in use is the one picked before if it still exists, else the first in the list (gui/src/redux/slices/
+// stateSlice.ts:186-192); PearAI appends its own models after the person's in memory (load.ts addDefaultModels), so the
+// gateway's entry, written first, is the default for anyone who has not picked a model.
+//
+// What is written (the same as Continue's config.json case, connectors/continue.ts):
+//   ~/.pearai/.env          BRAIN_GATEWAY_KEY=<key>  (0600, refreshed on a new sign-in)
+//   ~/.pearai/config.json   first in "models": {title: 100xprompt Pro, provider: openai, model, apiBase: <route>/v1,
+//                           apiKey: "BRAIN_GATEWAY_KEY", contextLength, requestOptions.headers x-100x-context-edit},
+//                           and "BRAIN_GATEWAY_KEY" in the top-level "env" list. Edited as text: comments stay, and
+//                           disconnect gives back the exact bytes.
+// Not covered: PearAI's agent ("PearAI Agent", a Roo Code fork), whose provider settings live in the editor's own storage.
+import { join } from "node:path"
+import type { Connector } from "../common.ts"
+import { ENTRY_KEY, envEdit, jsonCodec, jsonEntry, SECRET } from "./continue.ts"
+
+const dir = (home: string) => join(home, ".pearai")
+
+export const connectors: Connector[] = [
+  {
+    id: "pearai",
+    label: "PearAI",
+    file: (home) => join(dir(home), "config.json"),
+    probe: [".pearai"],
+    authHeader: "authorization",
+    edits: (home, s) => [
+      envEdit(dir(home), home),
+      { path: join(dir(home), "config.json"), format: "custom", codec: jsonCodec, values: { [ENTRY_KEY]: jsonEntry(s), [`env/${SECRET}`]: SECRET } },
+    ],
+    notes: [
+      "PearAI's chat now lists the gateway's model first; it is the default unless you picked another model before: then pick it once in the chat's model menu. PearAI's agent is not changed.",
+      `PearAI cannot read a key from another file, so the key is kept in ~/.pearai/.env as ${SECRET} (readable by you only), and config.json refers to it.`,
+    ],
+  },
+]