@yanzc/claude-pro 0.4.4 → 0.4.6

package/README.md

@@ -75,7 +75,7 @@ claude-pro config set CLAUDE_PRO_PROVIDER claude-code
 什么都没配置时（没有 `CLAUDE_PRO_PROVIDER`，也没有 `ANTHROPIC_BASE_URL`/`ANTHROPIC_AUTH_TOKEN`/`ANTHROPIC_API_KEY`/`ANTHROPIC_MODEL`）默认用**网关**，第一次启动直接弹出登录选择（网关排第一）；配置了 API 端点、密钥或模型的老用户仍然默认 `api`。交互界面里 `/login` 选择模型请求发往哪里（记在 `~/.claude-pro/settings.json` 的 `CLAUDE_PRO_PROVIDER`，每个后端各自记住 `/model`、`/effort`）：
 
 - **Claude 订阅**（`claude-code`）：本机 Claude Code 的登录，见上一节。
-- **网关**（`gateway`）：[codex-gateway](../codex-gateway) 的账户，默认 `https://gw.predix.icu`（`CLAUDE_PRO_GATEWAY_URL` 可改）。第一次选它会在浏览器打开网关的登录页，登录（或注册）后点“授权”，浏览器被带回本机，claude-pro 用一次性 code 换到这台电脑专用的 API Key，存在 `~/.claude-pro/gateway.json`（仅本人可读）。费用从网关账户余额扣，`/cost` 显示余额，充值和用量在网关的 `/user` 页面。模型默认 `opus`，`/model` 可选 `sonnet`、`haiku`、`gpt-6.1-sol`（网关用它自己的 Codex 登录转发，按 OpenAI 官方价扣费）；子 agent 在 Claude 主模型下用 `sonnet`。网关每次请求按 `max_tokens` 预扣余额，所以这里默认 `max_tokens` 是 32K。`/logout` 删除本机的网关 Key。
+- **网关**（`gateway`）：[codex-gateway](../codex-gateway) 的账户，默认 `https://gw.predix.icu`（`CLAUDE_PRO_GATEWAY_URL` 可改）。第一次选它会在浏览器打开网关的登录页，登录（或注册）后点“授权”，浏览器被带回本机，claude-pro 用一次性 code 换到这台电脑专用的 API Key，存在 `~/.claude-pro/gateway.json`（仅本人可读）。费用从网关账户余额扣，`/cost` 显示余额，充值和用量在网关的 `/user` 页面。模型默认 `opus`，`/model` 可选 `sonnet`、`haiku`、`gpt-6.1-sol`（网关用它自己的 Codex 登录转发，按 OpenAI 官方价扣费）；子 agent 在 Claude 主模型下用 `sonnet`。网关每次请求按 `max_tokens` 预扣余额，所以这里默认 `max_tokens` 是 32K。每个请求带上会话 ID（`X-Claude-Code-Session-Id`，和 Claude Code 一样；子 agent 用主对话的，`/clear` 换新的，`--resume` 和自动重启沿用原来的），网关据此让同一个对话 1 小时内继续用同一个上游账号，提示词缓存才不会因为换账号而失效。`/logout` 删除本机的网关 Key。
 - **Codex 订阅**（`codex`）：本机 `codex login`（ChatGPT 套餐）写下的 `~/.codex/auth.json`（`CODEX_HOME` 可改）。请求直接发往 Codex 后端，Anthropic 格式在本机和 OpenAI Responses 格式互相转换（工具调用、推理、缓存用量都对应上）；访问令牌快到期时用同一文件里的刷新令牌续期并写回，Codex CLI 也能接着用。模型默认取 `~/.codex/config.toml` 的 `model`，否则 `gpt-6.1-sol`；不设 effort 时用模型自己的默认值（`models_cache.json` 里写的）。
 
 ## 配置

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "claude-pro: a self-implemented coding agent for Anthropic-compatible APIs or local Claude Code subscription login. Full access with no permission prompts; file edits are checkpointed and can be rewound.",
   "type": "module",
   "repository": {

package/src/api.js

@@ -193,6 +193,9 @@ const outputCaps = new Map();
 // Models that refused the effort parameter (Haiku does): it is left out for them from then on.
 const noEffort = new Set();
 export const effortSupported = (modelId) => !noEffort.has(modelId);
+// Models that refused thinking "disabled" (MAX_THINKING_TOKENS=0): Opus 5.5, Fable, Sonnet 5.5, and Opus 5 at a
+// high effort. Their requests leave `thinking` out from then on, which is adaptive thinking.
+const thinkingStaysOn = new Set();
 
 // The effort a model uses when none is sent (docs.claude.com, "Effort"): medium on Opus 5.5 and Haiku 5.5, high on
 // the other models that take one; for a GPT model, the gateway's metadata or the local Codex models cache. null for
@@ -243,8 +246,10 @@ export function parseMaxTokensLimit(message) {
 // Codex backend only: Anthropic refuses their signatures ("Invalid `signature` in `thinking` block"), so a
 // conversation that moves from a GPT model to Claude, or to another provider, sends them without those blocks.
 // The session keeps them, for a later switch back. `inTurn`: blocks were taken out of the turn in progress (the
-// tool loop since the last prompt), whose assistant messages Anthropic wants to start with thinking when thinking
-// is on; such a turn goes on without thinking until the next prompt.
+// tool loop since the last prompt), whose assistant messages Anthropic wants to start with thinking when a thinking
+// budget is set; such a turn's requests leave `thinking` out until the next prompt. That is no thinking on older
+// models and adaptive thinking on those that cannot turn it off (Opus 5.5, Fable, Sonnet 5.5 refuse "disabled"),
+// which takes assistant messages without thinking.
 const isCodexThinking = (b) => b?.type === 'thinking' && typeof b.signature === 'string' && b.signature.startsWith(SIGNATURE_PREFIX);
 const isPrompt = (m) => m.role === 'user' && !(Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
 function withoutCodexThinking(messages) {
@@ -294,9 +299,9 @@ export function buildParams(config, { model, system, messages, tools, maxTokens,
   const eff = effortToSend(config, model.id, (effort === undefined ? config.effort : effort) || (/^gpt-/i.test(model.id) ? defaultEffort(model.id, config) : null));
   if (eff && !noEffort.has(model.id)) params.output_config = { effort: eff };
   const budget = config.thinkingBudget;
-  if (budget === 0) params.thinking = { type: 'disabled' };
+  if (budget === 0 && !thinkingStaysOn.has(model.id)) params.thinking = { type: 'disabled' };
   else if (budget > 0) params.thinking = { type: 'enabled', budget_tokens: Math.min(budget, params.max_tokens - 1) };
-  if (turnLostThinking) params.thinking = { type: 'disabled' };
+  if (turnLostThinking) delete params.thinking;
   return params;
 }
 
@@ -365,6 +370,9 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
   }
   let client = getClient(config, login);
   const params = buildParams(config, request, login);
+  // The gateway keeps a conversation on the upstream account that served it, where its prompt cache is; the
+  // session id names the conversation, in the header Claude Code sends it in.
+  const options = { signal, ...(config.usesGateway && config.sessionId ? { headers: { 'X-Claude-Code-Session-Id': config.sessionId } } : {}) };
   let authReloaded = false;
   const refused = new Set(); // what the endpoint refused for this request: remembered once a request got through
   const retryState = { attempt: 0, rateLimitHits: 0, waitedMs: 0, overloaded: 0, overloadedWaitMs: 0 };
@@ -373,7 +381,7 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
     let emitted = false;
     const startedAt = Date.now(); // the cache TTL counts from the start of the request, not from the end of the reply
     try {
-      const stream = await client.messages.create(params, { signal });
+      const stream = await client.messages.create(params, options);
       if (paused) {
         const overloaded = paused.overloaded;
         paused = null;
@@ -477,6 +485,12 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
         delete params.output_config;
         continue;
       }
+      // A model whose thinking cannot be turned off: carry on with its adaptive thinking.
+      if (err.status === 400 && params.thinking?.type === 'disabled' && /thinking\.type\.disabled|"disabled"/i.test(err.message) && /not supported/i.test(err.message)) {
+        thinkingStaysOn.add(params.model);
+        delete params.thinking;
+        continue;
+      }
       // The endpoint does not take cache_control (or the 1-hour ttl) where it was sent: carry on without it
       // instead of failing the request, and do not send it there again (see refuseCache).
       if (err.status === 400 && /cache_control|\bttl\b/i.test(err.message)) {

package/src/print.js

@@ -62,6 +62,7 @@ export async function runPrint({ prompt, flags, cwd, stdout = process.stdout, st
     store.systemPrompt = loaded.systemPrompt;
     runtime.resumeSystemPrompt(loaded.systemPrompt); // continue behind the prompt (and the cache) the conversation had
   }
+  runtime.config.sessionId = store.id; // sent to the gateway with each request (see streamMessage)
   const ctrl = new AbortController();
   const onSigint = () => ctrl.abort();
   process.on('SIGINT', onSigint);

package/src/ui/repl.js

@@ -17,7 +17,7 @@ import {
 import { createRuntime } from '../runtime.js';
 import { SessionStore, firstUserText } from '../session.js';
 import { defaultEffort, effortSupported, effortToSend, quickQuery } from '../api.js';
-import { CONFIG_DIR, VERSION, APP_NAME, INSTALL_DIR, rememberChoice } from '../config.js';
+import { CONFIG_DIR, VERSION, APP_NAME, INSTALL_DIR } from '../config.js';
 import { readGatewayLogin } from '../gateway.js';
 import { TOPIC_TITLE_SYSTEM, topicTitlePrompt } from '../prompts.js';
 import { buildCommands } from '../commands.js';
@@ -210,6 +210,8 @@ export class App {
 
     await this.startPeer();
     this.runtime = await createRuntime({ cwd: this.cwd, flags: this.flags, io: this });
+    // The conversation's id, sent to the gateway with each request (see streamMessage); it follows /clear and /resume.
+    Object.defineProperty(this.runtime.config, 'sessionId', { get: () => this.store.id, configurable: true });
     this.commands = buildCommands(this);
     // Keys typed while starting up stay buffered in stdin until we listen.
     stdin.on('keypress', (str, key) => {
@@ -461,14 +463,13 @@ export class App {
   // In the process a restart started: take up the session where the one before it left it.
   resumeAfterRestart(state, resumable) {
     const cfg = this.config;
-    const kept = {};
-    if (state.modelOverride) cfg.modelOverride = kept.model = state.modelOverride;
-    if (state.effortOverride) cfg.effortOverride = kept.effort = state.effortOverride;
+    // The model and effort the session had, none chosen included: the remembered /model and /effort are shared by
+    // every window on this machine, and another one may have changed them since (an update restarts them all).
+    // A restart is not a choice either, so it leaves what is remembered as it is.
+    if ('modelOverride' in state) cfg.modelOverride = state.modelOverride || null;
+    if ('effortOverride' in state) cfg.effortOverride = state.effortOverride || null;
     // The Effort tool's level holds for the request the restart continues, not for the user's next one.
     if (state.effortBoost) { cfg.effortBoost = state.effortBoost; cfg.effortBoostKeepNext = Boolean(state.continueWith); }
-    // These were chosen with /model and /effort, which are kept for later sessions. One made by a version of
-    // the program that did not keep them yet is saved now.
-    try { rememberChoice(cfg.provider, kept); } catch { /* it still holds for this session */ }
     if (state.mode === 'plan') this.runtime.modes.setMode('plan');
     this.restarts = (Array.isArray(state.restarts) ? state.restarts : []).filter((t) => Number.isFinite(t));
     if (resumable) {