@100xprompt/brain 0.1.0 → 0.1.1

package/src/gateway/connectors/kimi-code.ts

@@ -0,0 +1,241 @@
+// Gateway connector for Kimi Code (Moonshot's TypeScript CLI, `kimi`; the successor of the archived Python Kimi CLI that
+// used ~/.kimi). Checked against @moonshot-ai/kimi-code 2.5.2 (the copy in ~/.cache/brain-wire/kimi-code, dist/main.mjs)
+// and https://moonshotai.github.io/kimi-code/en/configuration/config-files.html.
+//
+// Settings live in one TOML file, $KIMI_CODE_HOME/config.toml, else ~/.kimi-code/config.toml (main.mjs resolveKimiHome /
+// resolveConfigPath; docs "Config file location"). Keys are snake_case and read into camelCase (providerEntryFromToml):
+//   default_model = "<alias>"           the model alias used when none is given (-m)
+//   [providers.<id>]  type ("openai" = Chat Completions, also "openai_responses", "anthropic", ...), base_url, api_key or
+//                     api_key_env (the NAME of an exported variable), custom_headers (a string table, sent with every model
+//                     request: main.mjs resolveOutboundHeaders), env (more literal values)   (ProviderConfigSchema$1)
+//   [models.<alias>]  provider, model (sent to the API), max_context_size (required), capabilities, display_name (what the
+//                     UI shows: main.mjs `displayName ?? model ?? alias`)                       (ModelBaseSchema)
+// The key: Kimi Code takes it only as api_key (in the file), api_key_env (a variable the person exports; brain cannot set
+// one for a tool started from a shell), the env sub-table (in the file again) or its OAuth login. It cannot run a command
+// or read a file ("The documentation does not describe supplying a key by running a command or by reading a file"; no such
+// field in the schema). So the key is copied into config.toml: holdsKey (0600), and the provider table is a secret key
+// (hidden, never recorded, replaced on a new sign-in).
+//
+// What is written: default_model = "brain-gateway", [providers.brain-gateway] (type "openai", base_url <route>/v1, api_key,
+// custom_headers with x-100x-context-edit) and [models.brain-gateway] (the gateway's model id, shown as "100xprompt Pro").
+// Kimi Code needs no model list from the gateway for a provider of type "openai" (only its own "kimi" provider refreshes one).
+//
+// The core's TOML handling knows only Codex's table, so this file has its own codec: top-level keys are edited line by
+// line, and a table is one key ("providers/brain-gateway") replaced, added or removed as a whole block. Every other line,
+// comments included, stays as it was; a table brain added is removed with the blank line it brought, so disconnect gives
+// back the exact bytes. Before any change the codec makes a trial edit and refuses a file where that would not land
+// exactly on brain's entries (an inline `providers = {...}`, dotted keys, sub-tables of brain's tables, ...).
+import { join } from "node:path"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Json, modelName, readKey, routeUrl } from "../common.ts"
+
+export const kimiConfig = (home: string, env: Record<string, string | undefined>) => join(dirFromEnv(env, "KIMI_CODE_HOME", join(home, ".kimi-code")), "config.toml")
+
+// ---- TOML: top-level keys and whole tables ------------------------------------------------------------------------------
+
+const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+const tomlKey = (k: string) => (/^[A-Za-z0-9_-]+$/.test(k) ? k : JSON.stringify(k))
+const tomlValue = (v: unknown): string =>
+  typeof v === "string"
+    ? JSON.stringify(v)
+    : typeof v === "number" || typeof v === "boolean"
+      ? String(v)
+      : Array.isArray(v)
+        ? `[${v.map(tomlValue).join(", ")}]`
+        : `{ ${Object.entries(v as Json).map(([k, x]) => `${tomlKey(k)} = ${tomlValue(x)}`).join(", ")} }`
+
+const ANY_HEADER = /^[ \t]*\[/
+const quiet = (l: string) => l.trim() === "" || /^\s*#/.test(l)
+
+/** The ` # comment` after a `key = value` line (a # outside quotes), with the spaces before it. */
+function lineComment(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 === "#") {
+      let j = i
+      while (j > 0 && /[ \t]/.test(line[j - 1]!)) j--
+      return line.slice(j).trimEnd()
+    }
+  }
+  return ""
+}
+
+function tomlSet(text: string, key: string, value: unknown): string {
+  const nl = text === "" || text.endsWith("\n")
+  const lines = text ? text.replace(/\n$/, "").split("\n") : []
+  const slash = key.indexOf("/")
+  if (slash < 0) {
+    // A top-level key: its line before the first table, replaced in place (keeping a trailing comment), or added at the
+    // end of that part (before the comments that introduce the first table).
+    const first = lines.findIndex((l) => ANY_HEADER.test(l))
+    const preEnd = first < 0 ? lines.length : first
+    const re = new RegExp(`^[ \\t]*(?:${esc(key)}|"${esc(key)}"|'${esc(key)}')[ \\t]*=`)
+    const at = lines.slice(0, preEnd).findIndex((l) => re.test(l))
+    if (value === undefined) {
+      if (at >= 0) lines.splice(at, 1)
+    } else if (at >= 0) lines[at] = `${tomlKey(key)} = ${tomlValue(value)}${lineComment(lines[at]!)}`
+    else {
+      let ins = preEnd
+      if (first >= 0) while (ins > 0 && quiet(lines[ins - 1]!)) ins--
+      lines.splice(ins, 0, `${tomlKey(key)} = ${tomlValue(value)}`)
+    }
+  } else {
+    // A whole table [parent.name]: its header line and the lines up to the next header (the blank lines and comments
+    // just before that header belong to it, not to this table).
+    const parent = key.slice(0, slash)
+    const name = key.slice(slash + 1)
+    const head = new RegExp(`^[ \\t]*\\[[ \\t]*${esc(parent)}[ \\t]*\\.[ \\t]*(?:${esc(name)}|"${esc(name)}"|'${esc(name)}')[ \\t]*\\][ \\t]*(?:#.*)?$`)
+    const at = lines.findIndex((l) => head.test(l))
+    let end = at + 1
+    if (at >= 0) {
+      while (end < lines.length && !ANY_HEADER.test(lines[end]!)) end++
+      while (end > at + 1 && quiet(lines[end - 1]!)) end--
+    }
+    const block = value === undefined ? [] : [`[${tomlKey(parent)}.${tomlKey(name)}]`, ...Object.entries(value as Json).map(([k, x]) => `${tomlKey(k)} = ${tomlValue(x)}`)]
+    if (value === undefined) {
+      if (at >= 0) {
+        lines.splice(at, end - at)
+        // The blank line that was put before it when it was added.
+        if (at > 0 && lines[at - 1] === "") lines.splice(at - 1, 1)
+      }
+    } else if (at >= 0) lines.splice(at, end - at, ...block)
+    else {
+      if (lines.length) lines.push("")
+      lines.push(...block)
+    }
+  }
+  return lines.length ? `${lines.join("\n")}${nl ? "\n" : ""}` : ""
+}
+
+const pathGet = (o: unknown, key: string): unknown => key.split("/").reduce<unknown>((cur, p) => (cur && typeof cur === "object" && !Array.isArray(cur) ? (cur as Json)[p] : undefined), o)
+
+const canon = (v: unknown): string =>
+  v instanceof Date
+    ? JSON.stringify(v.toISOString())
+    : 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)
+
+/** `o` without `key`, and without the tables that leaves empty (to compare the rest of a file). */
+function without(o: Json, key: string): Json {
+  const c = structuredClone(o)
+  const ps = key.split("/")
+  const parent = ps.length > 1 ? c[ps[0]!] : c
+  if (!parent || typeof parent !== "object") return c
+  delete (parent as Json)[ps[ps.length - 1]!]
+  if (ps.length > 1 && !Object.keys(parent).length) delete c[ps[0]!]
+  return c
+}
+
+/** Stand-ins for what brain writes: a trial edit with them must land exactly on those entries and change nothing else. */
+const TRIAL: Record<string, unknown> = {
+  default_model: "brain-trial",
+  "providers/brain-gateway": { type: "openai", base_url: "http://127.0.0.1/v1", custom_headers: { a: "b" } },
+  "models/brain-gateway": { provider: "brain-gateway", model: "m", max_context_size: 1, capabilities: ["tool_use"] },
+}
+
+/**
+ * Whether `providers` or `models`, or brain's entry in them, is written in a form a `[providers.brain-gateway]` table
+ * cannot be added next to (an inline table, dotted keys, a sub-table or an array of tables). TOML forbids defining a table
+ * twice and Kimi Code's parser enforces it; Bun's parser does not, so this is checked line by line.
+ */
+function unusualLayout(text: string): boolean {
+  let table: string | undefined
+  for (const l of text.split("\n")) {
+    const h = /^[ \t]*(\[\[?)([^\]]*)\]/.exec(l)
+    if (h) {
+      table = h[2]!.replace(/[\s"']/g, "")
+      if (/^(providers|models)\.brain-gateway\./.test(table) || (h[1] === "[[" && /^(providers|models)(\.|$)/.test(table))) return true
+      continue
+    }
+    if (table === undefined && /^[ \t]*["']?(providers|models)["']?[ \t]*[.=]/.test(l)) return true
+    if ((table === "providers" || table === "models") && /^[ \t]*["']?brain-gateway["']?[ \t]*[.=]/.test(l)) return true
+  }
+  return false
+}
+
+/** Kimi Code's config.toml: top-level keys ("default_model") and whole tables ("providers/brain-gateway"). */
+export const kimiToml: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    let before: Json
+    try {
+      before = Bun.TOML.parse(text) as Json
+    } catch {
+      return "it is not valid TOML; left as it is"
+    }
+    try {
+      if (unusualLayout(text)) throw new Error("layout")
+      let t = text
+      for (const [k, v] of Object.entries(TRIAL)) t = tomlSet(t, k, v)
+      const after = Bun.TOML.parse(t) as Json
+      let rest = after
+      let was = before
+      for (const [k, v] of Object.entries(TRIAL)) {
+        if (canon(pathGet(after, k)) !== canon(v)) throw new Error(k)
+        rest = without(rest, k)
+        was = without(was, k)
+      }
+      if (canon(rest) !== canon(was)) throw new Error("other values moved")
+      // Where none of brain's entries is there yet, taking them out again must give back the very same text.
+      if (Object.keys(TRIAL).every((k) => pathGet(before, k) === undefined)) {
+        for (const k of Object.keys(TRIAL)) t = tomlSet(t, k, undefined)
+        if (t !== text) throw new Error("not reversible")
+      }
+    } catch {
+      return "brain cannot add its entries without touching other settings (an unusual layout: inline tables or dotted keys for providers or models?); left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    if (!text.trim()) return undefined
+    return pathGet(Bun.TOML.parse(text), key)
+  },
+  set: tomlSet,
+}
+
+export const PROVIDER = "brain-gateway"
+
+export const connectors: Connector[] = [
+  {
+    id: "kimi-code",
+    label: "Kimi Code",
+    file: kimiConfig,
+    probe: [".kimi-code"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [
+      {
+        path: kimiConfig(home, env),
+        format: "custom",
+        codec: kimiToml,
+        holdsKey: true,
+        secretKeys: [`providers/${PROVIDER}`],
+        values: {
+          default_model: PROVIDER,
+          [`providers/${PROVIDER}`]: {
+            type: "openai",
+            base_url: `${routeUrl(s)}/v1`,
+            api_key: readKey(home),
+            ...(s.contextEdit ? { custom_headers: { [EDIT_HEADER]: "on" } } : {}),
+          },
+          [`models/${PROVIDER}`]: {
+            provider: PROVIDER,
+            model: s.model,
+            max_context_size: 1048576,
+            capabilities: ["image_in", "tool_use"],
+            display_name: modelName(s.model),
+          },
+        },
+      },
+    ],
+    notes: [
+      "Kimi Code cannot read a key from a file or a command (only from its config.toml, or from a variable you export), so the key is kept in ~/.kimi-code/config.toml, which is now readable by you only (0600).",
+    ],
+  },
+]

package/src/gateway/connectors/kiro-cli.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Kiro CLI: none. It uses only Kiro's AWS-hosted models (sign-in required); ~/.kiro/settings/cli.json
+// picks a model by name (chat.defaultModel) and has no endpoint, provider or key (https://kiro.dev/docs/reference/settings/,
+// updated 2026-11-06; the BYOK request is still open: https://github.com/kirodotdev/Kiro/issues/8939).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/kiro-ide.ts

@@ -0,0 +1,6 @@
+// Gateway connector for Kiro IDE: none. Its model dropdown offers only Kiro's own models, served from AWS regions; there is
+// no custom model, endpoint or key (https://kiro.dev/docs/chat/model-selection/, updated 2026-10-24; BYOK request open since
+// 2026-05-28: https://github.com/kirodotdev/Kiro/issues/8939).
+import type { Connector } from "../common.ts"
+
+export const connectors: Connector[] = []

package/src/gateway/connectors/letta-code.ts

@@ -0,0 +1,170 @@
+// Gateway connector for Letta Code (`letta`, npm @letta-ai/letta-code). Checked against its source at 0.34.51
+// (github.com/letta-ai/letta-code, main at 0aed9a6, 2026-11-10; Letta Code is not installed here: wire/drivers/b.ts says
+// why) and docs.letta.com/letta-code/models.
+//
+// Letta Code has two backends, and only one of them makes its model calls from this machine:
+//   - Letta Cloud / a Letta server (the default, `letta backend cloud`): the agent runs on the server, which calls the
+//     model. Custom endpoints there are BYOK providers stored in the Letta account through the server's /v1/providers
+//     API (src/backend/api/providers.ts:111-152), and they "must be reachable from the public internet"
+//     (docs.letta.com/letta-code/models). Nothing on disk to change: those agents are left alone.
+//   - Local mode (`letta backend local`, or --backend local; src/cli/subcommands/backend.ts:27-79): agents live in
+//     ~/.letta/lc-local-backend and Letta Code calls the model itself through pi-ai. Its built-in "OpenAI-compatible"
+//     provider (/connect, stored in lc-local-backend/providers/auth.json) cannot be used: it offers only the models its
+//     GET <base>/v1/models returns (src/backend/dev/pi-openai-compatible-provider.ts:16-22; models are kept in memory
+//     only and "never fabricated from name strings": pi-models-runtime.ts:209, pi-model-factory.ts), and the gateway
+//     answers /v1/models with 403. A provider MOD can: Letta loads every .js/.mjs/.ts file in
+//     ${LETTA_CONFIG_DIR:-~/.letta}/mods (or the legacy ~/.letta/extensions) as trusted local code at start and on
+//     /reload (src/mods/paths.ts:20-53, mod-sources.ts:45-106, mod-engine.ts:1430-1490), and a mod's
+//     letta.providers.register(id, {...}) declares an OpenAI-compatible provider with a fixed model list, its own
+//     baseUrl, an apiKey and headers (src/backend/dev/pi-provider-mod-types.ts:68-82;
+//     src/skills/builtin/creating-mods/references/providers.md). Static models are never re-listed
+//     (pi-mod-provider.ts:98-122), `connect: false` makes it usable with no /connect step
+//     (registered-pi-provider-runtime.ts:62-73), `authHeader` sends `Authorization: Bearer <apiKey>` and `headers` go on
+//     every request (pi-mod-provider.ts:41-59,124-153).
+//
+// So brain writes one file it owns, <mods>/brain-gateway.mjs: a mod registering the provider "brain-gateway" (shown as
+// "100xprompt gateway", its model as modelName(s.model)) on OpenAI Chat Completions at <route>/v1, with the
+// context-edit header when on. The mod reads the key from the brain's key file each time it is activated, so the key is
+// never copied (and a new sign-in is picked up at the next start or /reload). disconnect deletes the file.
+//
+// Limits, said on connect: only local agents can use it; the model is chosen per agent (each local agent record keeps
+// its own model, src/backend/local/local-agent-record.ts; there is no global default-model setting,
+// src/settings-manager.ts:68-112), so the person picks it with /model. Letta adds its own x-letta-request-kind header
+// (src/backend/dev/pi-request-headers.ts).
+import { existsSync } from "node:fs"
+import { isAbsolute, join } from "node:path"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, keyPath, modelName, routeUrl } from "../common.ts"
+
+export const MOD_FILE = "brain-gateway.mjs"
+const MARK = "// Written by `brain gateway connect --tool letta-code`"
+const SETTINGS_LINE = /^const gateway = (.*)$/m
+
+/** ${LETTA_CONFIG_DIR:-~/.letta} (src/utils/settings-path.ts:10-22): the override counts when absolute and present. */
+function configDir(home: string, env: Env): string {
+  const o = env.LETTA_CONFIG_DIR?.trim()
+  return o && isAbsolute(o) && existsSync(o) ? o : join(home, ".letta")
+}
+
+/** Where Letta looks for global mods, as resolveDefaultGlobalModsDirectory does (src/mods/paths.ts:34-53). */
+export function modsDir(home: string, env: Env): string {
+  const fromEnv = (env.LETTA_MODS_DIR ?? env.LETTA_EXTENSIONS_DIR)?.trim()
+  if (fromEnv && existsSync(fromEnv)) return fromEnv
+  const mods = join(configDir(home, env), "mods")
+  if (existsSync(mods)) return mods
+  const legacy = join(configDir(home, env), "extensions")
+  return existsSync(legacy) ? legacy : mods
+}
+
+/** A JS literal for `v` (JSON, with the two line separators JSON leaves raw escaped, so it is safe on one line of code). */
+const literal = (v: unknown) => JSON.stringify(v).replace(/[\u2028\u2029]/g, (c) => `\\u${c.charCodeAt(0).toString(16)}`)
+
+/** The whole mod, from its settings: the only part that varies is the `const gateway = {...}` line. */
+export function renderMod(settings: Json): string {
+  if (!Object.keys(settings).length) return ""
+  return `${MARK}: it lets Letta Code's local agents use the
+// 100xprompt gateway ("100xprompt gateway" in /model). \`brain gateway disconnect --tool letta-code\` removes it; a
+// reconnect writes it again. The key is read from the brain's key file each time Letta Code starts or reloads mods.
+import { readFileSync } from "node:fs"
+
+const gateway = ${literal(settings)}
+
+export default function activate(letta) {
+  if (!letta?.capabilities?.providers || !gateway.baseUrl || !gateway.model) return
+  let apiKey
+  try {
+    apiKey = readFileSync(gateway.keyFile, "utf8").trim() || undefined
+  } catch {}
+  return letta.providers.register(gateway.provider, {
+    name: gateway.name,
+    description: "The 100xprompt gateway, set up by brain",
+    api: "openai-completions",
+    baseUrl: gateway.baseUrl,
+    ...(apiKey ? { apiKey } : {}),
+    authHeader: true,
+    ...(gateway.headers ? { headers: gateway.headers } : {}),
+    connect: false,
+    models: [
+      {
+        id: gateway.model,
+        name: gateway.modelName,
+        reasoning: false,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: gateway.contextWindow,
+        maxTokens: gateway.maxTokens,
+        compat: { supportsDeveloperRole: false, supportsReasoningEffort: false },
+      },
+    ],
+  })
+}
+`
+}
+
+/** The settings of a mod brain wrote (undefined for any other file). */
+function readSettings(text: string): Json | undefined {
+  if (!text.startsWith(MARK)) return undefined
+  const m = SETTINGS_LINE.exec(text)
+  if (!m) return undefined
+  try {
+    const v = JSON.parse(m[1]!)
+    return v && typeof v === "object" && !Array.isArray(v) ? v : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The mod file as settings: each key is one field of its `const gateway = {...}` line, and the file is generated whole
+ * from them (no fields: no file). A file brain did not write is refused; a brain file that was edited by hand reads as
+ * changed, so disconnect leaves it (and says so).
+ */
+export const lettaMod: Codec = {
+  check(text) {
+    if (!text.trim() || readSettings(text)) return undefined
+    return "a mod by that name that brain did not write is there; left as it is"
+  },
+  get(text, key) {
+    const s = readSettings(text)
+    if (!s) return undefined
+    return renderMod(s) === text ? s[key] : "(changed by hand)"
+  },
+  set(text, key, value) {
+    const s = { ...(readSettings(text) ?? {}) }
+    if (value === undefined) delete s[key]
+    else s[key] = value
+    return renderMod(s)
+  },
+}
+
+/** What 100xprompt's models take (Gemini 3.x Flash: 1M tokens in, 64k out). */
+const CONTEXT_WINDOW = 1_048_576
+const MAX_TOKENS = 65_536
+
+const modValues = (home: string, s: GatewaySettings): Record<string, unknown> => ({
+  provider: "brain-gateway",
+  name: "100xprompt gateway",
+  baseUrl: `${routeUrl(s)}/v1`,
+  model: s.model,
+  modelName: modelName(s.model),
+  contextWindow: CONTEXT_WINDOW,
+  maxTokens: MAX_TOKENS,
+  keyFile: keyPath(home),
+  ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+})
+
+export const connectors: Connector[] = [
+  {
+    id: "letta-code",
+    label: "Letta Code",
+    file: (home, env) => join(modsDir(home, env), MOD_FILE),
+    // Its local mode has been used here (the local backend's store); a mods folder counts too (the file's own folder).
+    probe: [".letta/lc-local-backend"],
+    authHeader: "authorization",
+    edits: (home, s, env) => [{ path: join(modsDir(home, env), MOD_FILE), format: "custom", codec: lettaMod, values: modValues(home, s) }],
+    notes: [
+      "Letta Code reaches the gateway through a provider mod brain wrote in its mods folder; the mod reads the key from the brain's key file each time Letta Code starts (or on /reload), so the key is not copied.",
+      "Only local agents (letta backend local, or --backend local) use it: agents on Letta Cloud or a Letta server call their model from that server and are not changed.",
+      "Letta Code keeps a model per agent: in each local agent, choose the 100xprompt gateway model with /model. After disconnect, an agent still set to it asks you to choose another.",
+    ],
+  },
+]

package/src/gateway/connectors/mastracode.ts

@@ -0,0 +1,91 @@
+// Gateway connector for Mastra Code (the `mastracode` CLI, npm `mastracode`, source mastra-ai/mastra/mastracode). Checked against
+// the source at tag mastracode@0.49.0 (the npm latest on 2026-11-10) and, for the same facts, mastracode@0.37.1 (the version
+// brain's session adapter was checked against). It is not installed on this machine (wire/drivers/f.ts), so there is no
+// real-tool check for it.
+//
+// Everything Mastra Code keeps is in one JSON file, settings.json in its app-data folder: $MASTRA_APP_DATA_DIR, else
+// ~/Library/Application Support/mastracode (macOS), %APPDATA%\mastracode (Windows), $XDG_DATA_HOME/mastracode or
+// ~/.local/share/mastracode (sdk/src/utils/project.ts:187-212; settings.ts:781-783 getSettingsPath).
+//   - `customProviders: [{name, url, apiKey?, models: [id]}]` adds an OpenAI-compatible provider (settings.ts:41-46). Its id
+//     is the slugged name, "100xprompt gateway" -> 100xprompt-gateway (settings.ts:785-792), its models are
+//     `<id>/<model>`, and a request goes to `<url>/chat/completions` through @ai-sdk/openai-compatible with
+//     `Authorization: Bearer <apiKey>` (sdk/src/agents/mastracode-gateway.ts:490-511; the key is the literal apiKey,
+//     :477-479). There is no key file, env or command form and no per-provider headers, so the key is COPIED into
+//     settings.json (made 0600; Mastra Code keeps a file's mode when it rewrites it, settings.ts:1519) and the
+//     context-edit header cannot be sent.
+//   - `customModelPacks: [{name, models: {build, plan, fast}, createdAt}]` plus `models.activeModelPackId: "custom:<name>"`
+//     make every mode's default model the pack's (settings.ts:34-38, 1393-1407 resolveModelDefaults), which is how
+//     Mastra Code's own /models picker saves a custom pack. That leaves the person's own modeDefaults untouched.
+// The file is plain JSON (settings.ts:1199 JSON.parse) that Mastra Code rewrites whole with JSON.stringify(_, null, 2)
+// (settings.ts:1537) and that always holds both lists; brain's list entries are found by name, so they survive those
+// rewrites, and the text editor (pi.ts) gives the exact bytes back on disconnect. A missing settings.json is refused: Mastra
+// Code writes it when its first-run setup finishes, and that setup picks a model pack of its own.
+import { existsSync } from "node:fs"
+import { join, resolve, sep } from "node:path"
+import { type Connector, type Env, type GatewaySettings, type Json, readKey, routeUrl } from "../common.ts"
+import { jsonText, PROVIDER_NAME } from "./pi.ts"
+
+/** Mastra Code's provider id for a custom provider: its name, slugged (settings.ts getCustomProviderId). */
+export const providerSlug = (name: string) =>
+  name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "provider"
+
+/** The pack's creation time: fixed, so a reconnect with the same settings changes nothing. */
+const CREATED = "2026-11-10T00:00:00.000Z"
+
+/** An env folder counts only inside this home (a throwaway home in tests never follows the real XDG_DATA_HOME). */
+const inside = (home: string, dir: string | undefined) => !!dir && dir.startsWith("/") && existsSync(dir) && resolve(dir).startsWith(resolve(home) + sep)
+
+export function appDir(home: string, env: Env, platform: string = process.platform): string {
+  const own = env.MASTRA_APP_DATA_DIR
+  if (own && existsSync(own)) return own
+  if (platform === "darwin") return join(home, "Library", "Application Support", "mastracode")
+  if (platform === "win32") return join(inside(home, env.APPDATA) ? env.APPDATA! : join(home, "AppData", "Roaming"), "mastracode")
+  return join(inside(home, env.XDG_DATA_HOME) ? env.XDG_DATA_HOME! : join(home, ".local", "share"), "mastracode")
+}
+
+const PROVIDERS_KEY = `customProviders[name=${PROVIDER_NAME}]`
+const PACK_KEY = `customModelPacks[name=${PROVIDER_NAME}]`
+
+export function mastraValues(home: string, s: GatewaySettings): Json {
+  const model = `${providerSlug(PROVIDER_NAME)}/${s.model}`
+  return {
+    // Key order as Mastra Code writes a provider back (parseCustomProviders), so its rewrites compare equal.
+    [PROVIDERS_KEY]: { name: PROVIDER_NAME, url: `${routeUrl(s)}/v1`, apiKey: readKey(home), models: [s.model] },
+    [PACK_KEY]: { name: PROVIDER_NAME, models: { build: model, plan: model, fast: model }, createdAt: CREATED },
+    "models/activeModelPackId": `custom:${PROVIDER_NAME}`,
+  }
+}
+
+const mastracode: Connector = {
+  id: "mastracode",
+  label: "Mastra Code",
+  file: (home, env) => join(appDir(home, env), "settings.json"),
+  // Its app-data folder (the main file's folder, also where mastra.db lives) is what the first run creates.
+  probe: [],
+  authHeader: "authorization",
+  edits: (home, s, env) => [
+    {
+      path: join(appDir(home, env), "settings.json"),
+      format: "custom",
+      codec: jsonText({
+        jsonc: false,
+        mustExist: "Mastra Code has not saved its settings yet; start mastracode once and finish its setup, then connect",
+        shape: { customProviders: "array", customModelPacks: "array", models: "object" },
+      }),
+      holdsKey: true,
+      secretKeys: [PROVIDERS_KEY],
+      values: mastraValues(home, s),
+    },
+  ],
+  notes: [
+    `Mastra Code now uses the "${PROVIDER_NAME}" custom provider for its build, plan and fast modes (the "${PROVIDER_NAME}" model pack). It can only take the key in its settings.json, so the file is now readable by you only (0600).`,
+    "Mastra Code cannot send extra headers to a custom provider: context editing applies only when the gateway turns it on for everyone.",
+    "Threads you already have keep their own model; observational memory and subagent models keep theirs (/om, /subagents). Picking another pack in /models switches back without disconnecting.",
+  ],
+}
+
+export const connectors: Connector[] = [mastracode]