fix(providers): canonicalize baseUrl across paste/test/save/inference

Users pasting the full inference endpoint URL (e.g. .../v1/chat/completions)
caused the /models probe to build nonsense paths like .../v1/chat/completions/v1/models,
which many OpenAI-compatible gateways black-hole into "connection timeout".
Hardcoded /v1 also corrupted vendors that use other version segments:
Zhipu GLM (/api/paas/v4), Volcengine (/api/v3), Google AI Studio (/v1beta/openai).

Centralize all base-URL handling in @open-codesign/shared:
  - stripInferenceEndpointSuffix: strip query/hash/trailing slash/endpoint suffix
  - ensureVersionedBase: trust any /v<n>[a-z\d]* segment; default /v1 otherwise
  - canonicalBaseUrl(url, wire): wire-aware root for config + SDK
  - modelsEndpointUrl(url, wire): GET /models URL for the Test button

Wire into every call site so paste -> test -> save -> inference all resolve
to the same base: connection-ipc.buildEndpointForWire, onboarding-ipc
.runListEndpointModels, AddCustomProviderModal.handleSave, and
core/agent.buildPiModel (defensive net for legacy configs).

Author: hqhq1025

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

@@ -596,6 +596,47 @@ describe('normalizeBaseUrl', () => {
       'https://generativelanguage.googleapis.com',
     );
   });
+
+  // Users often paste the full inference endpoint URL instead of the API root.
+  // Regression: without suffix stripping we'd build .../v1/chat/completions/v1/models,
+  // which many OpenAI-compatible gateways black-hole → "connection timeout".
+  describe('strips endpoint path suffixes', () => {
+    it('openai: /v1/chat/completions → /v1', () => {
+      expect(normalizeBaseUrl('https://api.example.com/v1/chat/completions', 'openai')).toBe(
+        'https://api.example.com/v1',
+      );
+    });
+
+    it('openai: /chat/completions (no /v1 prefix) → /v1', () => {
+      expect(normalizeBaseUrl('https://api.example.com/chat/completions', 'openai')).toBe(
+        'https://api.example.com/v1',
+      );
+    });
+
+    it('openai: /v1/responses → /v1', () => {
+      expect(normalizeBaseUrl('https://api.example.com/v1/responses', 'openai')).toBe(
+        'https://api.example.com/v1',
+      );
+    });
+
+    it('openai: /v1/models → /v1', () => {
+      expect(normalizeBaseUrl('https://api.example.com/v1/models', 'openai')).toBe(
+        'https://api.example.com/v1',
+      );
+    });
+
+    it('anthropic: /v1/messages → root', () => {
+      expect(normalizeBaseUrl('https://api.anthropic.com/v1/messages', 'anthropic')).toBe(
+        'https://api.anthropic.com',
+      );
+    });
+
+    it('openrouter: /v1/chat/completions with trailing slash → /v1', () => {
+      expect(normalizeBaseUrl('https://openrouter.ai/api/v1/chat/completions/', 'openrouter')).toBe(
+        'https://openrouter.ai/api/v1',
+      );
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------

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

@@ -5,7 +5,10 @@ import {
   ERROR_CODES,
   type SupportedOnboardingProvider,
   type WireApi,
+  canonicalBaseUrl,
+  ensureVersionedBase,
   isSupportedOnboardingProvider,
+  stripInferenceEndpointSuffix,
 } from '@open-codesign/shared';
 import { ipcMain } from './electron-runtime';
 import { getApiKeyForProvider, getCachedConfig } from './onboarding-ipc';
@@ -114,16 +117,19 @@ interface ProviderEndpoint {
  * so downstream path concatenation never produces duplicate segments.
  *
  * - anthropic: strip trailing /v1 — we append /v1/models internally
- * - openai / openrouter: ensure /v1 suffix — the API lives at <root>/v1/models
+ * - openai / openrouter: ensure a version segment exists — the API lives at
+ *   <root>/<version>/models (usually /v1, but Zhipu uses /v4, Volcengine
+ *   uses /v3, Google AI Studio uses /v1beta/openai). If the user already
+ *   encoded a version we trust it; otherwise we default to /v1.
  * - google: strip trailing /v1 or /v1beta — we append the full path internally
  */
 export function normalizeBaseUrl(
   baseUrl: string,
   provider: 'openai' | 'anthropic' | 'google' | 'openrouter',
 ): string {
-  const cleaned = baseUrl.replace(/\/+$/, ''); // strip trailing slashes
+  const cleaned = stripInferenceEndpointSuffix(baseUrl);
   if (provider === 'openai' || provider === 'openrouter') {
-    return cleaned.endsWith('/v1') ? cleaned : `${cleaned}/v1`;
+    return ensureVersionedBase(cleaned);
   }
   if (provider === 'anthropic') {
     return cleaned.replace(/\/v1$/, '');
@@ -144,14 +150,10 @@ function buildEndpointForWire(
   wire: WireApi,
   baseUrl: string,
 ): { url: string; normalizedBaseUrl: string } {
-  if (wire === 'anthropic') {
-    const cleaned = baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
-    return { url: `${cleaned}/v1/models`, normalizedBaseUrl: cleaned };
-  }
-  // openai-chat and openai-responses both expose /models at the v1 root.
-  const cleaned = baseUrl.replace(/\/+$/, '');
-  const withV1 = cleaned.endsWith('/v1') ? cleaned : `${cleaned}/v1`;
-  return { url: `${withV1}/models`, normalizedBaseUrl: withV1 };
+  const normalizedBaseUrl = canonicalBaseUrl(baseUrl, wire);
+  const url =
+    wire === 'anthropic' ? `${normalizedBaseUrl}/v1/models` : `${normalizedBaseUrl}/models`;
+  return { url, normalizedBaseUrl };
 }
 
 export function buildAuthHeadersForWire(

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

@@ -15,6 +15,7 @@ import {
   WireApiSchema,
   hydrateConfig,
   isSupportedOnboardingProvider,
+  modelsEndpointUrl,
 } from '@open-codesign/shared';
 import { defaultConfigDir, readConfig, writeConfig } from './config';
 import { dialog, ipcMain, shell } from './electron-runtime';
@@ -874,13 +875,7 @@ async function runListEndpointModels(raw: unknown): Promise<ListEndpointModelsRe
   if (typeof apiKey !== 'string' || apiKey.trim().length === 0) {
     return { ok: false, error: 'apiKey required' };
   }
-  const cleaned = baseUrl
-    .replace(/\/+$/, '')
-    .replace(/\/(chat\/completions|completions|responses|messages|models)$/, '');
-  const url =
-    parsedWire.data === 'anthropic'
-      ? `${cleaned.replace(/\/v1$/, '')}/v1/models`
-      : `${cleaned.endsWith('/v1') ? cleaned : `${cleaned}/v1`}/models`;
+  const url = modelsEndpointUrl(baseUrl, parsedWire.data);
   const headers: Record<string, string> =
     parsedWire.data === 'anthropic'
       ? { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' }

apps/desktop/src/renderer/src/components/AddCustomProviderModal.tsx

@@ -1,5 +1,5 @@
 import { useT } from '@open-codesign/i18n';
-import { type WireApi, detectWireFromBaseUrl } from '@open-codesign/shared';
+import { type WireApi, canonicalBaseUrl, detectWireFromBaseUrl } from '@open-codesign/shared';
 import { Button } from '@open-codesign/ui';
 import { AlertCircle, CheckCircle, Loader2, X } from 'lucide-react';
 import { useState } from 'react';
@@ -69,11 +69,15 @@ export function AddCustomProviderModal({ onSave, onClose, initialSetAsActive = t
     try {
       const slug = slugify(name);
       const id = `custom-${slug}-${Date.now().toString(36).slice(-4)}`;
+      // Canonicalize before persisting so pi-ai / Anthropic SDK always see
+      // the root they expect. Without this, a user pasting /v1/chat/completions
+      // would have it stored verbatim and then pi-ai would append another
+      // /chat/completions at inference time.
       await window.codesign.config.addProvider({
         id,
         name: name.trim() || id,
         wire,
-        baseUrl: baseUrl.trim(),
+        baseUrl: canonicalBaseUrl(baseUrl.trim(), wire),
         apiKey: apiKey.trim(),
         defaultModel: defaultModel.trim(),
         setAsActive: initialSetAsActive,

packages/core/src/agent.ts

@@ -38,6 +38,7 @@ import {
   ERROR_CODES,
   type ModelRef,
   type StoredDesignSystem,
+  canonicalBaseUrl,
 } from '@open-codesign/shared';
 import type { TSchema } from '@sinclair/typebox';
 import { buildTransformContext } from './context-prune.js';
@@ -258,12 +259,16 @@ function buildPiModel(
       ERROR_CODES.PROVIDER_BASE_URL_MISSING,
     );
   }
+  // Defensive: canonicalize stored baseUrl before handing to pi-ai. Rescues
+  // legacy configs that persisted pre-normalization (e.g. raw `/v1/chat/completions`
+  // pasted in an older build). No-op for configs saved post-fix.
+  const canonicalBase = wire ? canonicalBaseUrl(resolvedBaseUrl, wire) : resolvedBaseUrl;
   const out: PiModel = {
     id: model.modelId,
     name: model.modelId,
     api: apiForWire(wire),
     provider: model.provider,
-    baseUrl: resolvedBaseUrl,
+    baseUrl: canonicalBase,
     reasoning: true,
     input: ['text'],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },

packages/providers/src/validate.test.ts

@@ -113,4 +113,41 @@ describe('pingProvider', () => {
     const result = await pingProvider('openai', 'sk-test', 'https://proxy.duckcoding.com/v1/');
     expect(result).toEqual({ ok: true, modelCount: 1 });
   });
+
+  it('strips /v1/chat/completions suffix when user pastes the full endpoint', async () => {
+    mockFetch(async (url) => {
+      expect(url).toBe('https://proxy.example.com/v1/models');
+      return new Response(JSON.stringify({ data: [{ id: 'x' }] }), { status: 200 });
+    });
+    const result = await pingProvider(
+      'openai',
+      'sk-test',
+      'https://proxy.example.com/v1/chat/completions',
+    );
+    expect(result).toEqual({ ok: true, modelCount: 1 });
+  });
+
+  it('strips /chat/completions (no /v1 prefix) suffix', async () => {
+    mockFetch(async (url) => {
+      expect(url).toBe('https://proxy.example.com/v1/models');
+      return new Response(JSON.stringify({ data: [] }), { status: 200 });
+    });
+    await pingProvider('openai', 'sk-test', 'https://proxy.example.com/chat/completions');
+  });
+
+  it('strips /v1/messages suffix for Anthropic', async () => {
+    mockFetch(async (url) => {
+      expect(url).toBe('https://api.anthropic.com/v1/models');
+      return new Response(JSON.stringify({ data: [] }), { status: 200 });
+    });
+    await pingProvider('anthropic', 'sk-ant-test', 'https://api.anthropic.com/v1/messages');
+  });
+
+  it('strips /v1/responses suffix', async () => {
+    mockFetch(async (url) => {
+      expect(url).toBe('https://api.example.com/v1/models');
+      return new Response(JSON.stringify({ data: [] }), { status: 200 });
+    });
+    await pingProvider('openai', 'sk-test', 'https://api.example.com/v1/responses');
+  });
 });

packages/providers/src/validate.ts

@@ -3,6 +3,7 @@ import {
   ERROR_CODES,
   type SupportedOnboardingProvider,
   isSupportedOnboardingProvider,
+  stripInferenceEndpointSuffix,
 } from '@open-codesign/shared';
 
 export type ValidateResult =
@@ -16,13 +17,14 @@ interface ProviderEndpoint {
 
 /**
  * Normalize a user-supplied baseUrl so that appending /v1/models never
- * produces a double /v1/ segment.
+ * produces a double /v1/ segment, and so that pasting the full inference
+ * endpoint (e.g. /v1/chat/completions) still resolves to the API root.
  *
  * - openai / openrouter: strip trailing /v1 — we append /v1/models below
  * - anthropic: strip trailing /v1 — we append /v1/models below
  */
 function normalizeValidateBaseUrl(baseUrl: string): string {
-  return baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+  return stripInferenceEndpointSuffix(baseUrl).replace(/\/v1$/, '');
 }
 
 function endpoint(provider: SupportedOnboardingProvider, baseUrl?: string): ProviderEndpoint {