fix(core+desktop): cap Anthropic-proxy reasoning at medium; add test-provider

Two fixes:

1. reasoningForModel now accepts baseUrl. When provider is 'anthropic'
   but the baseUrl is not api.anthropic.com, we're talking to a proxy
   (Claude Code-style) that commonly gates reasoning by plan — only
   'medium' is accepted on the consumer tier. Default for that case is
   now 'medium' instead of 'high'. Direct Anthropic API still gets
   'high' for Claude 4.x.

   Also re-adds the 'claude-code-imported' case (kept getting dropped
   by retries) so the imported provider id also lands on 'medium'.

   Callers (generate + agent) now pass input.baseUrl through.

2. Adds the missing 'connection:v1:test-provider' IPC handler. The
   preload exposed testProvider(id) but main only registered
   test-active. Refactored resolveActiveCredentials into a shared
   resolveCredentialsForProvider(id) helper and factored the probe
   into runProviderTest() so both the active-only and by-id paths
   reuse it.

Caveat: if a user manually picked 'high' via the Reasoning Depth
dropdown, the per-provider override still wins (by design). Clearing
the override via the "Default (auto)" option now lands on 'medium'
when the baseUrl is a proxy.

Author: hqhq1025

apps/desktop/src/main/connection-ipc.ts

@@ -332,10 +332,11 @@ interface ActiveProviderCredentials {
   httpHeaders?: Record<string, string>;
 }
 
-function resolveActiveCredentials(): ActiveProviderCredentials | ConnectionTestError {
+function resolveCredentialsForProvider(
+  providerId: string,
+): ActiveProviderCredentials | ConnectionTestError {
   const cfg = getCachedConfig();
-  const active = cfg?.activeProvider;
-  if (cfg === null || active === undefined || active.length === 0) {
+  if (cfg === null || providerId.length === 0) {
     return {
       ok: false,
       code: 'IPC_BAD_INPUT',
@@ -344,32 +345,71 @@ function resolveActiveCredentials(): ActiveProviderCredentials | ConnectionTestE
     };
   }
   const entry =
-    cfg.providers[active] ??
-    (isSupportedOnboardingProvider(active) ? BUILTIN_PROVIDERS[active] : undefined);
+    cfg.providers[providerId] ??
+    (isSupportedOnboardingProvider(providerId) ? BUILTIN_PROVIDERS[providerId] : undefined);
   if (entry === undefined) {
     return {
       ok: false,
       code: 'IPC_BAD_INPUT',
-      message: `Provider "${active}" not found in config`,
+      message: `Provider "${providerId}" not found in config`,
       hint: 'Re-add the provider from Settings',
     };
   }
   let apiKey: string;
   try {
-    apiKey = getApiKeyForProvider(active);
+    apiKey = getApiKeyForProvider(providerId);
   } catch {
     // No stored key — provider may be keyless (IP-whitelisted proxy).
     apiKey = '';
   }
   return {
-    provider: active,
+    provider: providerId,
     wire: entry.wire,
     apiKey,
     baseUrl: entry.baseUrl,
     ...(entry.httpHeaders !== undefined ? { httpHeaders: entry.httpHeaders } : {}),
   };
 }
 
+function resolveActiveCredentials(): ActiveProviderCredentials | ConnectionTestError {
+  const cfg = getCachedConfig();
+  const active = cfg?.activeProvider;
+  if (active === undefined || active.length === 0) {
+    return {
+      ok: false,
+      code: 'IPC_BAD_INPUT',
+      message: 'No active provider configured',
+      hint: 'Complete onboarding first',
+    };
+  }
+  return resolveCredentialsForProvider(active);
+}
+
+async function runProviderTest(
+  creds: ActiveProviderCredentials,
+): Promise<ConnectionTestResponse> {
+  const { url } = buildEndpointForWire(creds.wire, creds.baseUrl);
+  const headers = buildAuthHeadersForWire(creds.wire, creds.apiKey, creds.httpHeaders);
+
+  let res: Response;
+  try {
+    res = await fetchWithTimeout(url, { method: 'GET', headers });
+  } catch (err) {
+    const { code, hint } = classifyNetworkError(err);
+    return {
+      ok: false,
+      code,
+      message: err instanceof Error ? err.message : 'Network request failed',
+      hint,
+    };
+  }
+  if (!res.ok) {
+    const { code, hint } = classifyHttpError(res.status);
+    return { ok: false, code, message: `HTTP ${res.status}`, hint };
+  }
+  return { ok: true };
+}
+
 export function registerConnectionIpc(): void {
   ipcMain.handle(
     'connection:v1:test',
@@ -494,30 +534,28 @@ export function registerConnectionIpc(): void {
   ipcMain.handle('connection:v1:test-active', async (): Promise<ConnectionTestResponse> => {
     const creds = resolveActiveCredentials();
     if (!('provider' in creds)) return creds;
-
-    const { url } = buildEndpointForWire(creds.wire, creds.baseUrl);
-    const headers = buildAuthHeadersForWire(creds.wire, creds.apiKey, creds.httpHeaders);
-
-    let res: Response;
-    try {
-      res = await fetchWithTimeout(url, { method: 'GET', headers });
-    } catch (err) {
-      const { code, hint } = classifyNetworkError(err);
-      return {
-        ok: false,
-        code,
-        message: err instanceof Error ? err.message : 'Network request failed',
-        hint,
-      };
-    }
-
-    if (!res.ok) {
-      const { code, hint } = classifyHttpError(res.status);
-      return { ok: false, code, message: `HTTP ${res.status}`, hint };
-    }
-    return { ok: true };
+    return runProviderTest(creds);
   });
 
+  // Tests a specific provider by id — used by the per-row "Test connection"
+  // button in Settings. Same probe as test-active but routed by id.
+  ipcMain.handle(
+    'connection:v1:test-provider',
+    async (_e, raw: unknown): Promise<ConnectionTestResponse> => {
+      if (typeof raw !== 'string' || raw.length === 0) {
+        return {
+          ok: false,
+          code: 'IPC_BAD_INPUT',
+          message: 'test-provider expects a provider id string',
+          hint: 'Internal error — missing provider id',
+        };
+      }
+      const creds = resolveCredentialsForProvider(raw);
+      if (!('provider' in creds)) return creds;
+      return runProviderTest(creds);
+    },
+  );
+
   // Fetch available models for a stored provider by ID — credentials resolved
   // from the encrypted config so the renderer never touches plaintext keys.
   ipcMain.handle(

packages/core/src/agent.ts

@@ -716,7 +716,8 @@ export async function generateViaAgent(
   // precedence, then the model-family default from reasoningForModel. If
   // neither yields a value the agent runs with 'off', matching
   // pi-agent-core's default.
-  const thinkingLevel = input.reasoningLevel ?? reasoningForModel(input.model) ?? 'off';
+  const thinkingLevel =
+    input.reasoningLevel ?? reasoningForModel(input.model, input.baseUrl) ?? 'off';
 
   // Build the Agent. convertToLlm narrows AgentMessage (may include custom
   // types) to the LLM-visible Message subset.

packages/core/src/index.ts

@@ -312,7 +312,7 @@ async function runModel(input: ModelRunInput): Promise<GenerateOutput> {
   log.info(`[${scope}] step=send_request`, ctx);
   const sendStart = Date.now();
   let result: GenerateResult;
-  let reasoning = reasoningForModel(input.model);
+  let reasoning = input.reasoningLevel ?? reasoningForModel(input.model, input.baseUrl);
   // Self-healing: if the upstream rejects on reasoning mismatch, flip the
   // knob once and retry. Handles new reasoning-mandatory models (and
   // not-supported models) without code changes.
@@ -531,16 +531,26 @@ const OPENROUTER_REASONING_MODEL_RE = new RegExp(
   'i',
 );
 
-export function reasoningForModel(model: ModelRef): ReasoningLevel | undefined {
-  // Whitelist by (provider, modelId) pair. Substring matches across providers
-  // are unsafe: an OpenRouter or Groq pass-through id like
-  // `anthropic/claude-4` or any third-party id containing "o1"/"r1" would
-  // otherwise silently enable reasoning on a model that does not support it.
-  // The whole point of this gate is to avoid silent fallbacks, so require
-  // both axes to match a first-party provider we trust.
+export function reasoningForModel(
+  model: ModelRef,
+  baseUrl?: string | undefined,
+): ReasoningLevel | undefined {
+  // Proxy detection: when the provider id is 'anthropic' but baseUrl points
+  // somewhere other than api.anthropic.com, we're talking to a Claude Code-
+  // style proxy. Those commonly gate reasoning by plan and consumer-tier
+  // accepts only 'medium'. Cap defaults at 'medium' so requests don't 400
+  // out of the gate; users on higher-tier proxies override via Settings →
+  // Reasoning depth.
+  const looksLikeAnthropicProxy =
+    model.provider === 'anthropic' &&
+    baseUrl !== undefined &&
+    baseUrl.length > 0 &&
+    !/(^|\/\/)api\.anthropic\.com($|[/:])/i.test(baseUrl);
+
   switch (model.provider) {
     case 'anthropic':
-      return CLAUDE_4_MODEL_RE.test(model.modelId) ? 'high' : undefined;
+      if (!CLAUDE_4_MODEL_RE.test(model.modelId)) return undefined;
+      return looksLikeAnthropicProxy ? 'medium' : 'high';
     case 'openai':
       return OPENAI_REASONING_MODEL_RE.test(model.modelId) ? 'high' : undefined;
     case 'openrouter':
@@ -549,11 +559,12 @@ export function reasoningForModel(model: ModelRef): ReasoningLevel | undefined {
       // — pi-ai may translate the knob differently across upstreams, and
       // 'medium' is a safer landing zone for unknown reasoning back-ends.
       return OPENROUTER_REASONING_MODEL_RE.test(model.modelId) ? 'medium' : undefined;
+    case 'claude-code-imported':
+      // Claude Code proxy endpoints gate reasoning tiers by plan — the
+      // consumer-tier endpoint only accepts "medium". Sending "high" (or
+      // letting pi-agent-core default up) yields a 400.
+      return CLAUDE_4_MODEL_RE.test(model.modelId) ? 'medium' : undefined;
     default:
-      // groq, cerebras, xai, mistral, bedrock, azure, vercel-ai-gateway:
-      // all pass-through or multi-tenant. Even if they serve a reasoning model,
-      // we cannot trust the model id alone, and pi-ai will silently drop or
-      // mistranslate the reasoning knob. Stay conservative.
       return undefined;
   }
 }