@yanzc/claude-pro 0.4.1 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "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

@@ -7,7 +7,7 @@ import { refreshClaudeCodeLogin, canRenewLogin } from './oauth.js';
 import { humanDuration, parseRateLimit, parseRetryAfter, planRetry, sleepUntil, timing } from './ratelimit.js';
 import { cacheControl, cachePlanOf, fingerprint } from './cache.js';
 import { readGatewayLogin, fetchGatewayModels, cachedGatewayModel, gatewayEffort, gatewayDefaultEffort } from './gateway.js';
-import { createCodexFetch, codexModels } from './codex/client.js';
+import { createCodexFetch, codexModels, codexEffort } from './codex/client.js';
 import { SIGNATURE_PREFIX } from './codex/translate-request.js';
 
 let cached = null;
@@ -197,21 +197,31 @@ export const effortSupported = (modelId) => !noEffort.has(modelId);
 // 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
 // a model that takes none or is not known.
+// The environment that says where the Codex install is: CODEX_HOME may be set in the shell only.
+const codexEnv = (config) => ({ ...process.env, ...(config?.env || {}) });
+const gatewayModelInfo = (config, id) => (config?.usesGateway ? cachedGatewayModel(readGatewayLogin(config.gatewayUrl), id) : null);
+
 export function defaultEffort(modelId, config = null) {
   const id = String(modelId || '');
   if (!effortSupported(id)) return null;
   if (/^gpt-/i.test(id)) {
-    if (config?.usesGateway) {
-      const login = readGatewayLogin(config.gatewayUrl);
-      return gatewayDefaultEffort(cachedGatewayModel(login, id)) || codexModels(config.env).models.find((m) => m.slug === id)?.defaultEffort || null;
-    }
-    return codexModels(config?.env).models.find((m) => m.slug === id)?.defaultEffort || null;
+    return gatewayDefaultEffort(gatewayModelInfo(config, id)) || codexModels(codexEnv(config)).models.find((m) => m.slug === id)?.defaultEffort || null;
   }
   if (/^claude-(?:opus|haiku)-5-5(?:-|$)/i.test(id)) return 'medium';
   if (/^claude-(?:fable|mythos|opus-(?:5|4-[5-8])|sonnet-(?:5|4-6))(?:-|$)/i.test(id)) return 'high';
   return null;
 }
 
+// The level a request for this model carries when `effort` is chosen: the nearest one the model takes. A GPT model
+// lists its own (the gateway's /v1/models, else the local Codex models cache). Claude has no "ultra", the level
+// above max that some GPT models take, which stays chosen when the user switches from such a model to Claude.
+export function effortToSend(config, modelId, effort) {
+  if (!effort) return effort;
+  if (!/^gpt-/i.test(modelId)) return effort === 'ultra' ? 'max' : effort;
+  const info = gatewayModelInfo(config, modelId);
+  return info ? gatewayEffort(info, effort) : codexEffort(modelId, effort, codexEnv(config));
+}
+
 // Pull the allowed maximum out of an error such as
 //   "max_tokens: 128000 > 64000, which is the maximum allowed number of output tokens for claude-..."
 //   "Invalid max_tokens value, the valid range of max_tokens is [1, 8192]"
@@ -277,8 +287,7 @@ export function buildParams(config, { model, system, messages, tools, maxTokens,
   }
   // A GPT model with no effort set gets its default from the gateway's model metadata (or the local Codex cache
   // when using the Codex provider), sent explicitly so that the footer and backend use the same level.
-  let eff = (effort === undefined ? config.effort : effort) || (/^gpt-/i.test(model.id) ? defaultEffort(model.id, config) : null);
-  if (config.usesGateway && /^gpt-/i.test(model.id)) eff = gatewayEffort(cachedGatewayModel(readGatewayLogin(config.gatewayUrl), model.id), eff);
+  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' };
@@ -344,7 +353,8 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
   if (config.usesGateway && /^gpt-/i.test(request.model?.id)) {
     const gatewayLogin = readGatewayLogin(config.gatewayUrl);
     if (gatewayLogin) {
-      try { await fetchGatewayModels(gatewayLogin, { signal }); } catch (e) { if (e.name === 'AbortError' || signal?.aborted) throw e; }
+      // A gateway that does not answer costs at most a few seconds once (see fetchGatewayModels), not the request.
+      try { await fetchGatewayModels(gatewayLogin, { signal }); } catch { if (signal?.aborted) throw Object.assign(new Error('aborted'), { name: 'AbortError', partial: [] }); }
     }
   }
   let client = getClient(config, login);

package/src/commands.js

@@ -6,8 +6,8 @@ import { c, padEnd, truncate } from './ui/ansi.js';
 import { SelectDialog } from './ui/dialogs.js';
 import { renderTodos, resultLines, formatTokens, formatDuration } from './ui/render.js';
 import { loadConfig, settingsFiles, updateSettingsFile, rememberChoice, applyRememberedChoices, KNOWN_KEYS, VERSION, APP_NAME, CONFIG_DIR } from './config.js';
-import { loginWithBrowser, readGatewayLogin, clearGatewayLogin, fetchGatewayAccount, fetchGatewayModels, cachedGatewayModel, gatewayEfforts, gatewayEffort, formatUsd } from './gateway.js';
-import { codexLoginSummary, codexModels, codexEfforts, codexEffort } from './codex/client.js';
+import { loginWithBrowser, readGatewayLogin, clearGatewayLogin, fetchGatewayAccount, fetchGatewayModels, cachedGatewayModel, gatewayEfforts, formatUsd } from './gateway.js';
+import { codexLoginSummary, codexModels, codexEfforts } from './codex/client.js';
 import { readClaudeCodeLogin } from './claude-code.js';
 import { SessionStore } from './session.js';
 import { memoryFiles, listAutoMemories } from './context.js';
@@ -15,7 +15,7 @@ import { INIT_PROMPT } from './prompts.js';
 import { loadCustomCommands, renderSkill, expandCommandBody, expandShellEmbeds } from './agents.js';
 import { listBackgroundShells } from './tools/bash.js';
 import { estimateTokens } from './agent.js';
-import { quickQuery, cacheRefusals, defaultEffort } from './api.js';
+import { quickQuery, cacheRefusals, defaultEffort, effortToSend } from './api.js';
 import { hasRipgrep } from './utils/shell.js';
 import { displayPath } from './utils/paths.js';
 import { rewind } from './checkpoints.js';
@@ -272,10 +272,8 @@ export function buildCommands(app) {
       if (!choice) {
         const configured = (cfg.env.CLAUDE_CODE_EFFORT_LEVEL || '').trim().toLowerCase() || 'auto';
         const fallback = defaultEffort(id, cfg);
-        // A level this GPT model does not take goes out as the nearest one it does.
-        const sent = cfg.effort && isGpt(id)
-          ? modelInfo ? gatewayEffort(modelInfo, cfg.effort) : codexEffort(id, cfg.effort)
-          : cfg.effort;
+        // A level this model does not take goes out as the nearest one it does.
+        const sent = effortToSend(cfg, id, cfg.effort);
         const current = !cfg.effort ? c.bold(`auto (${fallback ? `model default: ${fallback}` : 'not sent'})`)
           : `${c.bold(cfg.effort)}${sent !== cfg.effort ? c.yellow(` (${id} does not take it: sent as ${sent})`) : ''}`;
         choice = await app.showDialog(new SelectDialog({

package/src/gateway.js

@@ -69,11 +69,26 @@ export async function fetchGatewayAccount({ url, apiKey }, { fetchImpl = globalT
 
 // The models the gateway serves (GET /v1/models), fetched once per gateway and key. The reasoning fields are
 // optional so older gateways still work; when present they are kept with the model for /effort and requests.
+// Every GPT request waits for it the first time, so it gives up after a few seconds, and after a failure it is not
+// asked again for a minute: a gateway whose /v1/models fails must not slow down every request.
 const modelLists = new Map();
-export async function fetchGatewayModels({ url, apiKey }, { fetchImpl = globalThis.fetch, signal } = {}) {
+const modelListFailures = new Map(); // key -> {at, error}
+const MODELS_TIMEOUT_MS = 5000;
+const MODELS_RETRY_MS = 60_000;
+export async function fetchGatewayModels({ url, apiKey }, { fetchImpl = globalThis.fetch, signal, timeoutMs = MODELS_TIMEOUT_MS } = {}) {
   const key = `${normalizeGatewayUrl(url)}\n${apiKey}`;
   if (modelLists.has(key)) return modelLists.get(key);
-  const body = await gatewayJson(`${normalizeGatewayUrl(url)}/v1/models`, { headers: { authorization: `Bearer ${apiKey}` }, signal }, fetchImpl);
+  const failed = modelListFailures.get(key);
+  if (failed && Date.now() - failed.at < MODELS_RETRY_MS) throw failed.error;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  let body;
+  try {
+    body = await gatewayJson(`${normalizeGatewayUrl(url)}/v1/models`, { headers: { authorization: `Bearer ${apiKey}` }, signal: signal ? AbortSignal.any([signal, timeout]) : timeout }, fetchImpl);
+  } catch (e) {
+    if (!signal?.aborted) modelListFailures.set(key, { at: Date.now(), error: e });
+    throw e;
+  }
+  modelListFailures.delete(key);
   const list = (body.data || []).filter((m) => typeof m?.id === 'string').map((m) => ({
     ...m,
     supported_reasoning_levels: (Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : Array.isArray(m.reasoning_levels) ? m.reasoning_levels : [])

package/src/tools/peers.js

@@ -22,7 +22,9 @@ export const ListPeersTool = {
 
 export const MessagePeerTool = {
   name: 'MessagePeer',
-  description: `Send a task or a question to another claude-pro session running on this machine (ListPeers lists them). The other session's agent works on it in its own conversation and directory, and the final text of its answer comes back to you later as a <peer-message kind="reply"> message: you do not wait for it here. Use it to delegate work that belongs to another session's project or context, or to ask it something only it knows. Write the message so that it stands on its own: the other agent has not seen your conversation.`,
+  description: `Send a task or a question to another claude-pro session running on this machine (ListPeers lists them). The other session's agent works on it in its own conversation and directory, and the final text of its answer comes back to you later as a <peer-message kind="reply"> message: you do not wait for it here. Use it to delegate work that belongs to another session's project or context, or to ask it something only it knows. Write the message so that it stands on its own: the other agent has not seen your conversation.
+
+Send it once and wait for the answer: do not send reminders or "please report" follow-ups while the other session works. Messages that arrive while it is busy are handled together after what it is doing, so they only add to its work; the answer comes by itself when it is done.`,
   input_schema: {
     type: 'object',
     properties: {

package/src/ui/repl.js

@@ -16,9 +16,9 @@ import {
 } from './render.js';
 import { createRuntime } from '../runtime.js';
 import { SessionStore, firstUserText } from '../session.js';
-import { defaultEffort, effortSupported, quickQuery } from '../api.js';
+import { defaultEffort, effortSupported, effortToSend, quickQuery } from '../api.js';
 import { CONFIG_DIR, VERSION, APP_NAME, INSTALL_DIR, rememberChoice } from '../config.js';
-import { readGatewayLogin, cachedGatewayModel, gatewayEffort } from '../gateway.js';
+import { readGatewayLogin } from '../gateway.js';
 import { TOPIC_TITLE_SYSTEM, topicTitlePrompt } from '../prompts.js';
 import { buildCommands } from '../commands.js';
 import { canRestart, writeRestartState, runSelfCheck, watchSource, restartNote, RESTART_EXIT_CODE, MAX_RESTARTS, RESTART_WINDOW_MS } from '../restart.js';
@@ -30,7 +30,6 @@ import { estimateTokens } from '../agent.js';
 import { readClipboardImage, imageFromFile, watchClipboard } from '../utils/clipboard.js';
 import { checkForUpdate } from '../updater.js';
 import { PeerNode, peersEnabled, findPeer, peerMessagePrompt } from '../peers.js';
-import { codexEffort } from '../codex/client.js';
 
 // A model id as people say it: claude-sonnet-5-5 -> sonnet-5-5, claude-haiku-4-5-20251001 -> haiku-4-5.
 export const modelTag = (model) => String(model?.id ?? '').replace(/^claude-/, '').replace(/-\d{8}$/, '');
@@ -39,13 +38,9 @@ export const modelTag = (model) => String(model?.id ?? '').replace(/^claude-/, '
 // is left out when none is sent (auto) and for a model that does not take one.
 export function modelInfo(config) {
   const model = config.mainModel;
-  // A GPT model gets the nearest level it takes; gateway metadata wins over the local Codex cache.
-  const gatewayModel = config.usesGateway && /^gpt-/i.test(model.id)
-    ? cachedGatewayModel(readGatewayLogin(config.gatewayUrl), model.id) : null;
-  const chosen = config.effort && /^gpt-/i.test(model.id)
-    ? gatewayModel ? gatewayEffort(gatewayModel, config.effort) : codexEffort(model.id, config.effort)
-    : config.effort;
-  const effort = chosen && effortSupported(model.id) ? chosen : null;
+  // What the requests carry: the nearest level the model takes (none goes out as low on gpt-6.1-sol, ultra as max on Claude).
+  const sent = effortToSend(config, model.id, config.effort);
+  const effort = sent && effortSupported(model.id) ? sent : null;
   return { model: modelTag(model), effort };
 }
 
@@ -387,7 +382,11 @@ export class App {
     const text = error ? `The session failed before finishing: ${error.message || error}`
       : result?.interrupted ? `The user of ${this.peers.name} interrupted the work before it was finished.${result.text ? `\n\nWhat it had written:\n${result.text}` : ''}`
         : (result?.text || '(no answer text)');
-    for (const msg of tasks) {
+    // One answer per session, to its last message: several messages from it that waited for this turn were all
+    // handled in it, and sending the whole answer once for each would hand that session the same text again and again.
+    const lastOfEach = new Map();
+    for (const msg of tasks) lastOfEach.set(`${msg.from.id}|${msg.from.name}|${msg.from.cwd}`, msg);
+    for (const msg of lastOfEach.values()) {
       // by id, or by name: a session that was restarted by older code comes back with a new id
       const running = this.peers.peers();
       const peer = findPeer(running, msg.from.id) || running.find((p) => p.name === msg.from.name && p.cwd === msg.from.cwd);