pi-autothink

English · 中文说明

A Pi extension that decides how hard the model should think before every turn.

Typing fix this typo and redesign the auth layer no longer cost the same reasoning budget: a small classifier model scores the request, and Pi runs that turn at the matching thinking level.

Same model. Same context. Same prompt cache. Only the thinking level moves.

  you type a message
          │
          ▼
  ┌─────────────────────────┐      score 0–5
  │  classifier (Jev)       │ ─────────────────┐
  │  "how deep is this?"    │                  │
  └─────────────────────────┘                  ▼
                                     ┌──────────────────┐
                                     │  thinking level  │
                                     │ minimal … max    │
                                     └────────┬─────────┘
          ┌───────────────────────────────────┘
          ▼
  clamp to what your model supports  →  run the turn  →  log the decision to the session

Quick start

pi install npm:pi-autothink          # or: pi install git:github.com/loofare/pi-autothink

Then restart Pi (or /reload) and check it is live:

/autothink status

It is on by default. Turn it off with /autothink off or PI_AUTO_THINKING=0.

Set up JEV (5 minutes)

JEV is hosted — there is nothing to install and no local model to download. It is a classifier that answers one question about a piece of text; Pi already knows how to call it. All that is missing is one credential.

This plugin never stores that credential. It asks Pi, and Pi keeps keys in ~/.pi/agent/auth.json. Log in once and every Pi extension can use it — the plugin depends on Pi for auth, on purpose.

1. Get a key

Sign up at console.typesafe.ai and create an API key.

2. Hand it to Pi

Inside a Pi session:

/login typesafe

Paste the key. Pi writes it to ~/.pi/agent/auth.json (mode 600) and handles the rest.

3. Check what the plugin found

/autothink status

A healthy install says:

auto thinking: on
classifier: typesafe/jev-latest
classifier source: built-in candidate list
level bounds: none
current level: medium
config: none (defaults)
last decision: low (jev 1.06/5)

If classifier: says none — keyword fallback, nothing is connected yet: run /autothink setup, which re-checks and shows the exact command for each option.

4. Nothing to configure after that

It runs on every prompt. Tune it later with the optional config file below.

No TypeSafe account? Five other routes

Every one of these ends up in the same place: Pi holds the credential, the plugin finds it.

Troubleshooting

Optional config file

No config needed. When you want one:

• user: ~/.pi/agent/pi-autothink/config.json
• project: <project>/.pi/pi-autothink/config.json (wins over the user file)

{
  "minLevel": "low",
  "maxLevel": "high",
  "timeoutMs": 3000,
  "model": "typesafe/jev-latest",
  "enabled": true,
  "debug": false,
  "maxPromptChars": 6000
}

Precedence: environment variable → project config → user config → built-in default. A bad value (typo, wrong type, minLevel above maxLevel) is ignored with a warning, never fatal.

Why this exists

Pi stores the thinking level next to the model selection, so it stays wherever you left it. That leaves two habits, both bad:

Thinking tokens are billed as output. This extension puts one cheap classifier call in front of each turn so the level follows the work instead of your mood.

Requirements

Missing the credential? It still works. No classifier, an error, or a 4-second timeout falls back to a local keyword heuristic instead of blocking the turn.

How it decides

The classifier gets one scored question — how much internal reasoning does completing this request need? Judge the work itself, not its tone or length — and answers on this scale:

Two details that matter:

• Score 0 → minimal, never off. Deciding not to think at all stays your call, not the classifier's.
• The result is clamped to your model. The requested level is pulled to the nearest level the active model actually supports, so an unsupported level never reaches the provider.

Request text is clipped to 6000 characters. Timeout is 4000 ms.

Controls

What it does not do

Being explicit about the edges is cheaper than debugging them later:

Audit trail

Every decision lands in the session as an auto-thinking custom entry — outside the LLM context, with no prompt text, credentials, or user content:

{"requested":"medium","applied":"low","clamped":true,"source":"jev",
 "classifier":"typesafe/jev-latest","model":"some/model","detail":"jev 2.31/5"}

requested is what the classifier said, applied is what actually ran, and clamped says whether the model could not honour it. Retries and recoveries reuse the previous decision instead of paying for another classifier call.

Install variants

pi install npm:pi-autothink                          # npm
pi install git:github.com/loofare/pi-autothink        # git
pi install ./pi-autothink                            # local checkout
pi -e /path/to/pi-autothink                          # try once, don't add to settings

License

MIT