@100xprompt/brain 0.1.1 → 0.1.3

package/README.md

@@ -96,6 +96,9 @@ brain gateway logout
 - Connecting changes which model the tool uses: it runs on 100xprompt Pro by default (`--model flash` for 100xprompt
   Flash), billed to your 100xprompt account. Context editing is on by default; `--no-context-edit` turns it off and is
   remembered for later connects until `--context-edit`.
+- `--model auto` connects the tool to 100xprompt Auto (the gateway's `/auto` route): each kind of work (everyday asks,
+  code, reasoning) moves to a cheaper model only when your company's own test of its logs (in the Savings app) proved it
+  no worse, and stays on 100xprompt Pro until then. `--model pro` or `--model flash` switches back.
 - Before changing anything, `connect` checks that the gateway accepts your key the way that tool sends it (a free check
   that generates nothing). If your account's quota is used up, it still connects and tells you, in the gateway's words.
 - Only the settings brain owns are written; the value each had before is recorded and put back by `disconnect`. The key

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100xprompt/brain",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "One working session, any AI coding tool: move sessions between Claude Code, Codex, Cursor, Gemini CLI, OpenCode and more, keep what projects learned, spend fewer tokens. Runs on Bun. By 100xprompt.",
   "license": "MIT",
   "author": "Nipurn Agarwal",

package/src/dashboard/report.ts

@@ -8,7 +8,7 @@ import { join } from "node:path"
 import type { Reader } from "../adapters/types.ts"
 import { toolLabel } from "../brief.ts"
 import { DEFAULT_MODEL, DEFAULT_ROUTE, type Env, type GatewaySettings, modelName, statePath } from "../gateway/common.ts"
-import { CONNECTORS, hasKey, installedHere } from "../gateway/connect.ts"
+import { CONNECTORS, cliAuthPath, hasKey, installedHere } from "../gateway/connect.ts"
 import { HOOK_TOOLS, hookInstalled } from "../hooks.ts"
 import { MCP_TOOLS, statusMcp } from "../memory/mcp-install.ts"
 import { chittaCandidates, memoryDbPath, openMemory } from "../memory/store.ts"
@@ -182,6 +182,20 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
       return false
     }
   }
+  /**
+   * The 100xprompt CLI is the gateway's own client: there is nothing for brain to connect, and it is on the gateway
+   * whenever it is signed in (its auth.json holds a key; only its presence is looked at). Signed out, it can be
+   * (`100xprompt auth login`). Any other tool: undefined, decided by brain's connectors.
+   */
+  const ownClient = (id: string, h: string, e: Env): Harness["gateway"] | undefined => {
+    if (id !== "100xprompt") return undefined
+    try {
+      const k = JSON.parse(readFileSync(cliAuthPath(h, e), "utf8"))?.["100xprompt"]?.key
+      return typeof k === "string" && k.trim() ? "connected" : "available"
+    } catch {
+      return "available"
+    }
+  }
   const known = new Map<string, { label: string; present: boolean }>()
   const add = (id: string, label: string, present: boolean) => {
     const k = known.get(id)
@@ -207,7 +221,7 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
       label: clip(k.label, 80),
       sessions: counts?.[id] ? counts[id]!.sessions : null,
       lastSessionAt: counts?.[id]?.lastSessionAt ?? null,
-      gateway: connected[id] ? "connected" : connectorIds.has(id) ? "available" : "unsupported",
+      gateway: connected[id] ? "connected" : (ownClient(id, home, env) ?? (connectorIds.has(id) ? "available" : "unsupported")),
       mcp: mcpIds.has(id) ? mcpInstalled.get(id) === true : null,
       hooks: HOOK_TOOLS.includes(id) ? hookOn(id) : null,
     }))

package/src/gateway/common.ts

@@ -12,15 +12,66 @@ export const DEFAULT_ROUTE = "flash"
 export const DEFAULT_MODEL = "gemini-3.8-flash"
 export const EDIT_HEADER = "x-100x-context-edit"
 
+/**
+ * `--model auto`: the gateway's auto-routing (the router's docs/routing-contract.md, "The /auto route"). Its route serves
+ * only this model id, and this id only on its route: per kind of work (everyday asks, code, reasoning) the gateway serves
+ * a cheaper model where the company's own test in the Savings app proved it no worse, and 100xprompt Pro everywhere else.
+ */
+export const AUTO_ROUTE = "auto"
+export const AUTO_MODEL = "100xprompt-auto"
+
 /**
  * What 100xprompt calls the models brain may connect a tool to, as the 100xprompt CLI shows them: tools are given the
  * gateway's model id (that is what the gateway serves), and everything brain prints uses the product name.
  */
-export const MODEL_NAMES: Record<string, string> = { "gemini-3.8-flash": "100xprompt Pro", "gemini-3.7-flash": "100xprompt Flash", "gemini-3.6-flash": "100xprompt Flash" }
-/** `--model pro` / `--model flash`: the product names, turned into the gateway's model ids. */
-export const MODEL_ALIASES: Record<string, string> = { pro: "gemini-3.8-flash", flash: "gemini-3.7-flash" }
+export const MODEL_NAMES: Record<string, string> = {
+  "gemini-3.8-flash": "100xprompt Pro",
+  "gemini-3.7-flash": "100xprompt Flash",
+  "gemini-3.6-flash": "100xprompt Flash",
+  "gemini-3.5-flash": "100xprompt Flash",
+  [AUTO_MODEL]: "100xprompt Auto",
+}
+/** `--model pro` / `--model flash` / `--model auto`: the product names, turned into the gateway's model ids. */
+export const MODEL_ALIASES: Record<string, string> = { pro: "gemini-3.8-flash", flash: "gemini-3.7-flash", auto: AUTO_MODEL }
 export const modelName = (id: string) => MODEL_NAMES[id] ?? id
 export const modelId = (given: string) => MODEL_ALIASES[given.trim().toLowerCase()] ?? given.trim()
+/**
+ * Whether a connect uses auto-routing. No tool knows this id: a connector whose tool sizes its context window (or picks
+ * its capabilities) from the model id it is given tells it, for auto, what every model auto may serve takes (limitsFor).
+ */
+export const isAuto = (s: Pick<GatewaySettings, "model">) => s.model === AUTO_MODEL
+/** What the Gemini Flash models behind 100xprompt Pro and Flash take: 1,048,576 tokens in, 65,536 out. */
+export const GEMINI_LIMITS = { context: 1_048_576, output: 65_536 } as const
+/**
+ * What every model auto-routing may serve takes (the contract's table: the Gemini Flash models and DeepSeek V4 Flash): the
+ * smaller window, DeepSeek V4 Flash's 1,000,000 tokens, and Gemini's 65,536 out (DeepSeek allows more). Both take text and
+ * images; audio, video and PDF only Gemini, so a tool told what it may send gets images only.
+ */
+export const AUTO_LIMITS = { context: 1_000_000, output: 65_536 } as const
+/** The context window and output limit a connector tells its tool, for the model it connects. */
+export const limitsFor = (s: Pick<GatewaySettings, "model">) => (isAuto(s) ? AUTO_LIMITS : GEMINI_LIMITS)
+
+/**
+ * The route and model a connect uses, from the flags given (undefined: not given) and the settings stored by the last
+ * connect. The auto model and the auto route go together: `--model auto` picks the auto route (a different --route with
+ * it is refused), `--route auto` picks the auto model, and another model or route after an auto connect goes back to the
+ * default route (flash) or model (100xprompt Pro).
+ */
+export function routeAndModel(given: { route?: string; model?: string }, stored: { route?: string; model?: string } = {}): { route: string; model: string } | { why: string } {
+  const model = given.model !== undefined ? modelId(given.model) : undefined
+  const route = given.route
+  if (model === AUTO_MODEL) {
+    if (route !== undefined && route !== AUTO_ROUTE) return { why: `--model auto uses the gateway's ${AUTO_ROUTE} route, so it cannot be combined with --route ${route}; leave out --route` }
+    return { route: AUTO_ROUTE, model }
+  }
+  if (route === AUTO_ROUTE) {
+    if (model !== undefined) return { why: `the ${AUTO_ROUTE} route chooses the model itself, so it cannot be combined with --model ${given.model!.trim()}; use --model auto` }
+    return { route: AUTO_ROUTE, model: AUTO_MODEL }
+  }
+  const wasAuto = stored.model === AUTO_MODEL || stored.route === AUTO_ROUTE
+  if (route === undefined && model === undefined) return wasAuto ? { route: AUTO_ROUTE, model: AUTO_MODEL } : { route: stored.route ?? DEFAULT_ROUTE, model: stored.model ?? DEFAULT_MODEL }
+  return { route: route ?? (wasAuto ? DEFAULT_ROUTE : (stored.route ?? DEFAULT_ROUTE)), model: model ?? (wasAuto ? DEFAULT_MODEL : (stored.model ?? DEFAULT_MODEL)) }
+}
 
 export interface GatewaySettings {
   url: string
@@ -46,7 +97,8 @@ export function readKey(home: string): string {
 }
 
 /**
- * The gateway route's base address, e.g. https://proxy.100xprompt.com/flash. Under it the gateway serves, for every model:
+ * The gateway route's base address, e.g. https://proxy.100xprompt.com/flash (or /auto, which takes the same paths). Under
+ * it the gateway serves, for every model:
  *   /v1/chat/completions   OpenAI Chat Completions (Authorization: Bearer <key>)
  *   /v1/responses          OpenAI Responses (Authorization: Bearer <key>)
  *   /v1/messages           Anthropic Messages (x-api-key: <key>, or Authorization: Bearer)

package/src/gateway/connect.ts

@@ -34,9 +34,9 @@ import {
   type Json,
   keyPath,
   MODEL_NAMES,
-  modelId,
   modelName,
   readKey,
+  routeAndModel,
   routeUrl,
   setAt,
   shellQuote,
@@ -46,6 +46,8 @@ import { EXTRA_CONNECTORS } from "./connectors/index.ts"
 import { askHidden, browserSignIn, type SignInDeps } from "./signin.ts"
 
 export {
+  AUTO_MODEL,
+  AUTO_ROUTE,
   DEFAULT_MODEL,
   DEFAULT_ROUTE,
   DEFAULT_URL,
@@ -593,15 +595,18 @@ export async function connect(
   if (!c) return { ok: false, lines: [`unknown tool "${toolId}"; \`brain gateway tools\` lists the ones that can be connected`] }
   if (!hasKey(home) && !o.dryRun) return { ok: false, lines: ["not signed in to the gateway yet: run `brain gateway login`"] }
   const st = loadState(home)
+  // --model auto goes with the auto route (and back to flash after it): common.ts routeAndModel.
+  const rm = routeAndModel({ route: o.settings?.route, model: o.settings?.model }, st.settings ?? {})
+  if ("why" in rm) return { ok: false, lines: [rm.why] }
   const s: GatewaySettings = {
     url: o.settings?.url ?? st.settings?.url ?? DEFAULT_URL,
-    route: o.settings?.route ?? st.settings?.route ?? DEFAULT_ROUTE,
-    model: o.settings?.model !== undefined ? modelId(o.settings.model) : (st.settings?.model ?? DEFAULT_MODEL),
+    route: rm.route,
+    model: rm.model,
     contextEdit: o.settings?.contextEdit ?? st.settings?.contextEdit ?? true,
   }
   if (!/^https?:\/\/[^\s]+$/.test(s.url) || (/^http:/.test(s.url) && !/^http:\/\/(127\.0\.0\.1|localhost)(:|\/|$)/.test(s.url))) return { ok: false, lines: ["--url must be https:// (http:// only for a gateway on this machine)"] }
   if (!/^[a-z0-9-]{1,40}$/.test(s.route)) return { ok: false, lines: ["--route must be a gateway route name such as flash or pro"] }
-  if (!/^[\w.:/-]{1,80}$/.test(s.model)) return { ok: false, lines: ["--model must be pro, flash or a plain model name"] }
+  if (!/^[\w.:/-]{1,80}$/.test(s.model)) return { ok: false, lines: ["--model must be pro, flash, auto or a plain model name"] }
   const main = c.file(home, env)
   if (!installedHere(c, home, env)) return { ok: false, lines: [`${c.label} has not been run on this machine (nothing at ${main}); run it once, then connect it`] }
   let limit: string | undefined
@@ -748,7 +753,7 @@ const USAGE = [
   "brain gateway login [--no-browser]        sign in to 100xprompt in your browser, as `100xprompt auth login` does",
   "brain gateway login --key-env VAR | --from-cli   take the key from VAR (scripts, CI) or from the 100xprompt CLI's sign-in",
   "brain gateway logout                      forget the key",
-  "brain gateway connect --tool <id> [--model pro|flash] [--route flash] [--url https://...] [--no-context-edit | --context-edit] [--dry-run] [--no-probe]",
+  "brain gateway connect --tool <id> [--model pro|flash|auto] [--route flash] [--url https://...] [--no-context-edit | --context-edit] [--dry-run] [--no-probe]",
   "brain gateway disconnect --tool <id> [--dry-run]",
   "brain gateway status | tools",
 ]

package/src/gateway/connectors/aider.ts

@@ -29,15 +29,12 @@
 //   Docs: https://aider.chat/docs/config/adv-model-settings.html (extra_params, extra_headers, metadata file),
 //         https://aider.chat/docs/llms/openai-compat.html (openai/<model> against an OpenAI-compatible API).
 import { join } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Json, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Json, limitsFor, readKey, routeUrl, yamlTopLevel } from "../common.ts"
 
 /** The one key of brain's own entry in the settings list and in the metadata object. */
 export const AIDER_ENTRY = "brain-gateway"
 /** Marks brain's entry in each file (a YAML comment, a JSON5 comment), so it is told apart from the person's own. */
 export const AIDER_MARK = "100xprompt gateway, added by brain gateway connect --tool aider"
-/** What Aider is told about the gateway's model: the Gemini Flash models' window and output limit. */
-const CONTEXT = 1_048_576
-const OUTPUT = 65_536
 
 const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
 
@@ -337,7 +334,8 @@ export const connectors: Connector[] = [
           path: join(home, ".aider.model.metadata.json"),
           format: "custom",
           codec: modelMetadataJson,
-          values: { [AIDER_ENTRY]: { [model]: { max_input_tokens: CONTEXT, max_output_tokens: OUTPUT, max_tokens: OUTPUT, litellm_provider: "openai", mode: "chat" } } },
+          // The Gemini Flash models' window and output limit, or for 100xprompt Auto what every model it may serve takes.
+          values: { [AIDER_ENTRY]: { [model]: { max_input_tokens: limitsFor(s).context, max_output_tokens: limitsFor(s).output, max_tokens: limitsFor(s).output, litellm_provider: "openai", mode: "chat" } } },
         },
         {
           path: join(home, ".aider.conf.yml"),

package/src/gateway/connectors/cline-sdk.ts

@@ -26,12 +26,9 @@
 // not followed; CLINE_DIR and CLINE_DATA_DIR are, when they exist. The VS Code extension (id `cline`, see cline.ts) shares
 // ~/.cline/data but chooses its provider from its own globalState.json, so this connector does not change it.
 import { join } from "node:path"
-import { type Connector, dirFromEnv, EDIT_HEADER, type Env, modelName, readKey, routeUrl } from "../common.ts"
+import { type Connector, dirFromEnv, EDIT_HEADER, type Env, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 const ID = "brain-gateway"
-/** Gemini 3.x Flash, which the gateway's models are: a 1M-token window, 64K out. */
-const CONTEXT_WINDOW = 1_048_576
-const MAX_OUTPUT = 65_536
 /** Cline requires an ISO date here; a fixed one keeps edits() free of side effects (Cline sets its own when it saves). */
 const UPDATED_AT = "2026-01-01T00:00:00.000Z"
 
@@ -56,7 +53,7 @@ export const connectors: Connector[] = [
             version: 1,
             [`providers/${ID}`]: {
               provider: { name: "100xprompt gateway", baseUrl, defaultModelId: s.model, protocol: "openai-chat", client: "openai-compatible", capabilities: ["tools", "streaming"] },
-              models: { [s.model]: { id: s.model, name: modelName(s.model), contextWindow: CONTEXT_WINDOW, maxTokens: MAX_OUTPUT, capabilities: ["tools", "streaming", "images"] } },
+              models: { [s.model]: { id: s.model, name: modelName(s.model), contextWindow: limitsFor(s).context, maxTokens: limitsFor(s).output, capabilities: ["tools", "streaming", "images"] } },
             },
           },
         },

package/src/gateway/connectors/continue.ts

@@ -30,7 +30,8 @@
 //                         apiKey: ${{ secrets.BRAIN_GATEWAY_KEY }}, roles chat/edit/apply/summarize,
 //                         capabilities tool_use and image_input (Continue only guesses tool support for provider openai from
 //                         gpt-/o- model names, toolSupport.ts ~277661, so without it Agent mode would be off),
-//                         contextLength 1048576 (an unknown model gets 32768, ~238017), and the context-edit header.
+//                         contextLength 1048576 (an unknown model gets 32768, ~238017; for 100xprompt Auto the
+//                         smallest window auto may serve, common.ts limitsFor), and the context-edit header.
 //                       First in the list makes it the default: the extension and the CLI take the first chat model unless
 //                       one was picked before (extension rectifySelectedModelsFromGlobalContext ~798703; CLI
 //                       services/ModelService.ts:53-120 and util/modelPersistence.ts, `cliSelectedModel`).
@@ -42,7 +43,7 @@
 // stay, and removing the entry gives back the exact bytes, including an empty `models: []` or a list that was not there.
 import { existsSync, readFileSync } from "node:fs"
 import { isAbsolute, join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, limitsFor, modelName, readKey, routeUrl, yamlTopLevel } from "../common.ts"
 
 /** The name the key is kept under in the tool's .env, and that its config refers to. */
 export const SECRET = "BRAIN_GATEWAY_KEY"
@@ -50,8 +51,6 @@ export const SECRET = "BRAIN_GATEWAY_KEY"
 const OWN_CONFIG = "100xprompt gateway"
 /** The codec key of brain's entry in the models list (the entry itself is found by its apiKey, so a model switch keeps it). */
 export const ENTRY_KEY = "models/100xprompt gateway"
-/** Gemini models' context window; Continue assumes 32768 for a model it does not know. */
-const CONTEXT = 1048576
 
 const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
 const isPlainObject = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v)
@@ -521,7 +520,7 @@ const headers = (s: GatewaySettings) => (s.contextEdit ? { requestOptions: { hea
 
 /** The models entry in config.json form (older Continue, PearAI): `title`, the key by env name. */
 export function jsonEntry(s: GatewaySettings, extra: Json = {}): Json {
-  return { title: modelName(s.model), provider: "openai", model: s.model, apiBase: `${routeUrl(s)}/v1`, apiKey: SECRET, contextLength: CONTEXT, ...extra, ...headers(s) }
+  return { title: modelName(s.model), provider: "openai", model: s.model, apiBase: `${routeUrl(s)}/v1`, apiKey: SECRET, contextLength: limitsFor(s).context, ...extra, ...headers(s) }
 }
 
 /** The .env edit both Continue and PearAI read their secret from. */
@@ -557,7 +556,7 @@ export const connectors: Connector[] = [
         apiKey: `\${{ secrets.${SECRET} }}`,
         roles: ["chat", "edit", "apply", "summarize"],
         capabilities: ["tool_use", "image_input"],
-        defaultCompletionOptions: { contextLength: CONTEXT },
+        defaultCompletionOptions: { contextLength: limitsFor(s).context },
         ...headers(s),
       }
       return [

package/src/gateway/connectors/crush.ts

@@ -30,7 +30,7 @@
 // A model list is given, so Crush does not ask the gateway for /v1/models (403 there).
 import { existsSync } from "node:fs"
 import { isAbsolute, join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, limitsFor, modelName, routeUrl, shellQuote } from "../common.ts"
 
 /** Crush's data file, resolved as Crush does; the env overrides describe the person's real home, so they count only there. */
 export function crushDataFile(home: string, env: Env): string {
@@ -297,7 +297,7 @@ export const connectors: Connector[] = [
               base_url: `${routeUrl(s)}/v1`,
               api_key: `$(cat ${shellQuote(keyPath(home))})`,
               ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
-              models: [{ id: s.model, name: modelName(s.model), context_window: 1048576, default_max_tokens: 65536, capabilities: { vision: true } }],
+              models: [{ id: s.model, name: modelName(s.model), context_window: limitsFor(s).context, default_max_tokens: limitsFor(s).output, capabilities: { vision: true } }],
             },
             "models/large": pick,
             "models/small": pick,

package/src/gateway/connectors/factory-droid.ts

@@ -14,6 +14,10 @@
 //     stdout."), run with shell:true, cached for 5 minutes (apiKeyHelperTtlMs, FACTORY_API_KEY_HELPER_TTL_MS). So the key
 //     is read from the brain's key file at run time, never copied, and a new sign-in reaches Droid without a reconnect.
 //   - `extraHeaders` is sent with every request (case-insensitively unique names), so the context-edit header can go.
+//   - Context window and output limit: Droid infers a custom model's from its model id (the built-in model whose
+//     matchPatterns match it: gemini-3.8-flash gets Gemini 3.8 Flash's 1M in and 64K out), and an entry's maxContextLimit
+//     and maxOutputTokens take precedence (k4e and ev in the binary). 100xprompt Auto's id matches nothing, so for auto they
+//     are given: what every model auto may serve takes (common.ts limitsFor). Images stay on (noImageSupport unset).
 //   - A model's id is `custom:<displayName with spaces as ->-<n>` unless the entry names its own `id`; this connector gives
 //     its entry the id `custom:brain-gateway`, so the default stays put whatever else is in the list.
 //   - The default model is `sessionDefaultSettings.model` (older top-level `model` is folded into it on read and only
@@ -27,7 +31,7 @@
 //   - Checked for real (scripts/gateway-real/factory-droid.ts): `droid exec` with no -m, no Factory login, sends its
 //     request to <route>/v1/messages with x-api-key from the helper, the context-edit header and the gateway's model.
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, isAuto, type Json, keyPath, limitsFor, modelName, routeUrl, shellQuote } from "../common.ts"
 
 /** The id of the connector's entry in customModels, and the default model value that selects it. */
 export const DROID_MODEL_ID = "custom:brain-gateway"
@@ -295,6 +299,7 @@ export const connectors: Connector[] = [
             provider: "anthropic",
             apiKeyHelper: `cat ${shellQuote(keyPath(home))}`,
             ...(s.contextEdit ? { extraHeaders: { [EDIT_HEADER]: "on" } } : {}),
+            ...(isAuto(s) ? { maxContextLimit: limitsFor(s).context, maxOutputTokens: limitsFor(s).output } : {}),
           },
           "sessionDefaultSettings/model": DROID_MODEL_ID,
         },

package/src/gateway/connectors/goose.ts

@@ -22,12 +22,10 @@
 //   The binary's strings list the same field names (`strings goose | grep api_key_env`), and the real-tool check
 //   (scripts/gateway-real/goose.ts) runs this exact setup.
 import { isAbsolute, join, resolve } from "node:path"
-import { type Connector, EDIT_HEADER, type Env, keyPath, modelName, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Connector, EDIT_HEADER, type Env, keyPath, limitsFor, modelName, routeUrl, yamlTopLevel } from "../common.ts"
 
 /** The provider id (the custom provider's file name and `name`, and GOOSE_PROVIDER), as Codex and OpenCode name it. */
 export const GOOSE_PROVIDER = "brain-gateway"
-/** The context window Goose is told (it compacts the conversation near it): the Gemini Flash models' 1,048,576 tokens. */
-const CONTEXT_LIMIT = 1_048_576
 
 /** Goose's config folder, found the way Goose finds it. XDG_CONFIG_HOME describes the real home, so it counts only there. */
 export function gooseDir(home: string, env: Env): string {
@@ -56,7 +54,9 @@ export const connectors: Connector[] = [
           display_name: "100xprompt gateway",
           description: `${modelName(s.model)} through the 100xprompt gateway (set up by brain gateway connect --tool goose)`,
           base_url: `${routeUrl(s)}/v1`,
-          models: [{ name: s.model, context_limit: CONTEXT_LIMIT }],
+          // The window Goose is told (it compacts the conversation near it): the Gemini Flash models' 1,048,576 tokens, or
+          // for 100xprompt Auto the smallest window it may serve (common.ts limitsFor).
+          models: [{ name: s.model, context_limit: limitsFor(s).context }],
           ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
           supports_streaming: true,
           requires_auth: true,

package/src/gateway/connectors/hermes.ts

@@ -19,7 +19,10 @@
 //   - `extra_headers` on the provider entry is sent with every request on the OpenAI wire (runtime_provider.py
 //     _lift_extra_headers), so the context-edit header can go.
 //   - The gateway's /v1/models answers 403; Hermes then takes the context window from its catalog ("gemini" → 1M,
-//     agent/model_metadata.py), so nothing else needs setting.
+//     agent/model_metadata.py), so nothing else needs setting for a Gemini id. 100xprompt Auto's id is in no catalog (Hermes
+//     would assume 256,000: DEFAULT_FALLBACK_CONTEXT), so for auto the entry also gets `models: {<id>: {context_length}}`,
+//     the per-model override Hermes checks before any catalog (hermes_cli/config.py get_custom_provider_context_length,
+//     matched by the entry's base_url): what every model auto may serve takes (common.ts limitsFor).
 //   - $HERMES_HOME replaces ~/.hermes when set (a Hermes profile is its own HERMES_HOME).
 //   - Checked for real (scripts/gateway-real/hermes.ts): `hermes chat -q` sends its request to <route>/v1/chat/completions
 //     with Authorization: Bearer <key from .env>, the context-edit header and the gateway's model, even with the person's
@@ -27,7 +30,7 @@
 // config.yaml is YAML with comments; the codec below edits `<section>/<entry>` lines in place and leaves every other line
 // as it was.
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type Json, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, isAuto, type Json, limitsFor, readKey, routeUrl, yamlTopLevel } from "../common.ts"
 
 export const HERMES_PROVIDER = "brain-gateway"
 export const HERMES_KEY_VAR = "BRAIN_GATEWAY_API_KEY"
@@ -209,6 +212,7 @@ export const connectors: Connector[] = [
             api_mode: "chat_completions",
             default_model: s.model,
             ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
+            ...(isAuto(s) ? { models: { [s.model]: { context_length: limitsFor(s).context } } } : {}),
           },
           "model/provider": `custom:${HERMES_PROVIDER}`,
           "model/default": s.model,

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

@@ -26,7 +26,7 @@
 // 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"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Json, limitsFor, 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")
 
@@ -227,7 +227,7 @@ export const connectors: Connector[] = [
           [`models/${PROVIDER}`]: {
             provider: PROVIDER,
             model: s.model,
-            max_context_size: 1048576,
+            max_context_size: limitsFor(s).context,
             capabilities: ["image_in", "tool_use"],
             display_name: modelName(s.model),
           },

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

@@ -33,7 +33,7 @@
 // (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"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, keyPath, limitsFor, modelName, routeUrl } from "../common.ts"
 
 export const MOD_FILE = "brain-gateway.mjs"
 const MARK = "// Written by `brain gateway connect --tool letta-code`"
@@ -136,18 +136,15 @@ export const lettaMod: Codec = {
   },
 }
 
-/** 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,
+  // What the model takes (Gemini 3.x Flash: 1M tokens in, 64k out; for 100xprompt Auto, what every model it may serve takes).
+  contextWindow: limitsFor(s).context,
+  maxTokens: limitsFor(s).output,
   keyFile: keyPath(home),
   ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
 })

package/src/gateway/connectors/openhands.ts

@@ -25,9 +25,14 @@
 //     (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.
+//   - With max_input_tokens and max_output_tokens null, the SDK looks the model up in LiteLLM's catalog, under the id and
+//     under the part after the last "/" (sdk/llm/utils/model_info.py get_litellm_model_info): gemini-3.8-flash is there
+//     (1,048,576 in, 65,536 out, images). 100xprompt Auto's id is not, so for auto both are set to what every model auto may
+//     serve takes (common.ts limitsFor). Images: OpenHands decides them from that same catalog only (llm.py
+//     _supports_vision; there is no setting to turn them on), so with auto it sends no images.
 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"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, isAuto, type Json, limitsFor, readKey, routeUrl } from "../common.ts"
 
 // ---- JSON edited in place ------------------------------------------------------------------------------------------------
 
@@ -261,8 +266,8 @@ const llmValues = (prefix: string, home: string, s: GatewaySettings): Record<str
   [`${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}/max_input_tokens`]: isAuto(s) ? limitsFor(s).context : null,
+  [`${prefix}/max_output_tokens`]: isAuto(s) ? limitsFor(s).output : null,
   [`${prefix}/litellm_extra_body`]: {},
 })
 
@@ -289,7 +294,7 @@ export const connectors: Connector[] = [
     },
     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.",
+      "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 (with 100xprompt Auto they are set instead, and OpenHands sends no images: it decides that from the model's name alone).",
       "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/qwen-code.ts

@@ -20,13 +20,18 @@
 //     under a name of its own (BRAIN_GATEWAY_KEY, so no OPENAI_API_KEY of the person's is touched), and that file is 0600.
 //   - Custom headers: generationConfig.customHeaders is sent with every request (chunks/chunk-ESPAP3UW.js buildHeaders),
 //     so `x-100x-context-edit: on` goes there.
+//   - Context window and input kinds: Qwen Code takes them from the model id (chunks/chunk-5TODR7F6.js tokenLimit and
+//     defaultModalities: gemini-* gets 1,000,000 tokens and every input kind; an id it does not know gets 200,000 and text
+//     only), unless the provider entry's generationConfig gives contextWindowSize and modalities (chunks/chunk-KUBWE5YV.js
+//     ModelRegistry, MODEL_GENERATION_CONFIG_FIELDS). 100xprompt Auto's id is one it cannot know, so for auto they are given:
+//     what every model auto may serve takes (common.ts limitsFor), images and text.
 // What connect writes: settings.json gets a "brain-gateway" provider ("100xprompt gateway", model shown as its 100xprompt
 // name), its providerProtocol mapping, and the selection (auth type, model.name, model.baseUrl); ~/.qwen/.env gets the
 // key. The person's own providers, models and comments are left as they are; disconnect puts every key back.
 // Needs Qwen Code 0.23 or later (custom provider ids through providerProtocol); older ones skip the provider.
 import { existsSync } from "node:fs"
 import { join } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, isAuto, type Json, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 // ---- JSON with comments, edited in place ----------------------------------------------------------------------------
 //
@@ -372,6 +377,15 @@ export function qwenDir(home: string, env: Env): string {
 
 const base = (s: GatewaySettings) => `${routeUrl(s)}/v1`
 
+/** The provider entry's generationConfig: the context-edit header, and for auto the window and input kinds (see above). */
+function generationConfig(s: GatewaySettings): Json | undefined {
+  const g: Json = {
+    ...(s.contextEdit ? { customHeaders: { [EDIT_HEADER]: "on" } } : {}),
+    ...(isAuto(s) ? { contextWindowSize: limitsFor(s).context, modalities: { image: true } } : {}),
+  }
+  return Object.keys(g).length ? g : undefined
+}
+
 export const connectors: Connector[] = [
   {
     id: "qwen-code",
@@ -392,7 +406,7 @@ export const connectors: Connector[] = [
               description: "100xprompt gateway",
               baseUrl: base(s),
               envKey: QWEN_KEY_VAR,
-              ...(s.contextEdit ? { generationConfig: { customHeaders: { [EDIT_HEADER]: "on" } } } : {}),
+              ...(generationConfig(s) ? { generationConfig: generationConfig(s) } : {}),
             },
           ],
           [`providerProtocol/${PROVIDER}`]: "openai",

package/src/gateway/connectors/vscode-copilot.ts

@@ -27,13 +27,10 @@
 // Only the default VS Code profile and VS Code Stable ("Code") are handled; Insiders, VSCodium and other profiles keep
 // their own User folders.
 import { join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type Json, modelName, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type Json, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 const GROUP = "100xprompt gateway"
 const VENDOR = "customendpoint"
-/** Gemini 3.x Flash, which the gateway's models are: a 1M-token window, 64K out. */
-const MAX_OUTPUT = 65_536
-const MAX_INPUT = 1_048_576 - MAX_OUTPUT
 
 /** VS Code's user folder: ~/Library/Application Support/Code/User on macOS, $XDG_CONFIG_HOME/Code/User or ~/.config/Code/User elsewhere. */
 export function vscodeUserDir(home: string, env: Env, platform: string = process.platform): string {
@@ -268,8 +265,9 @@ export const connectors: Connector[] = [
                 apiType: "chat-completions",
                 toolCalling: true,
                 vision: true,
-                maxInputTokens: MAX_INPUT,
-                maxOutputTokens: MAX_OUTPUT,
+                // The window less the output (Gemini 3.x Flash: 1M in, 64K out; 100xprompt Auto: what all it may serve take).
+                maxInputTokens: limitsFor(s).context - limitsFor(s).output,
+                maxOutputTokens: limitsFor(s).output,
                 requestHeaders: { Authorization: `Bearer ${readKey(home)}`, ...(s.contextEdit ? { [EDIT_HEADER]: "on" } : {}) },
               },
             ],