fix(desktop): degrade-probe matches wire endpoint (#179 follow-up)

Signed-off-by: hqhq1025 <1506751656@qq.com>

Author: hqhq1025

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

@@ -1012,10 +1012,11 @@ describe('runProviderTest degrade-probe (issue #179)', () => {
     }
   });
 
-  it('openai-responses: /models 404 + /chat/completions 2xx → degrade pass', async () => {
-    const { restore } = installFakeFetch((url) => {
+  it('openai-responses: /models 404 + /responses 2xx → probeMethod=responses_degraded', async () => {
+    const { calls, restore } = installFakeFetch((url) => {
       if (url.endsWith('/models')) return { status: 404 };
-      return { status: 200, body: { ok: true } };
+      if (url.endsWith('/responses')) return { status: 200, body: { ok: true } };
+      return { status: 500 };
     });
     try {
       const res = await runProviderTest({
@@ -1025,7 +1026,48 @@ describe('runProviderTest degrade-probe (issue #179)', () => {
         baseUrl: 'https://gateway.example.com/v1',
       });
       expect(res.ok).toBe(true);
-      if (res.ok) expect(res.probeMethod).toBe('chat_completion_degraded');
+      if (res.ok) expect(res.probeMethod).toBe('responses_degraded');
+      expect(calls).toHaveLength(2);
+      expect(calls[0]?.url).toMatch(/\/models$/);
+      expect(calls[1]?.url).toMatch(/\/responses$/);
+      expect(calls[1]?.method).toBe('POST');
+      const body = JSON.parse(calls[1]?.body ?? '{}');
+      // Responses API shape — must NOT look like /chat/completions payload.
+      expect(body.max_output_tokens).toBe(1);
+      expect(Array.isArray(body.input)).toBe(true);
+      expect(body.messages).toBeUndefined();
+    } finally {
+      restore();
+    }
+  });
+
+  it('openai-responses: /models 404 + /responses 404 → preserves original 404 (no /chat/completions false-positive)', async () => {
+    // Regression: the previous implementation probed /chat/completions for
+    // every OpenAI-compat wire. A gateway that only implements /chat/completions
+    // would then report the connection healthy even though real inference (on
+    // /responses) would 404 at generate-time. We want the opposite: if the
+    // wire's real endpoint is dead, the test must fail.
+    const { calls, restore } = installFakeFetch((url) => {
+      if (url.endsWith('/models')) return { status: 404 };
+      if (url.endsWith('/responses')) return { status: 404 };
+      // A gateway that only has /chat/completions — must not be consulted.
+      if (url.endsWith('/chat/completions')) return { status: 200, body: { id: 'wrong-probe' } };
+      return { status: 500 };
+    });
+    try {
+      const res = await runProviderTest({
+        provider: 'chat-only-gateway',
+        wire: 'openai-responses',
+        apiKey: 'sk-test',
+        baseUrl: 'https://gateway.example.com/v1',
+      });
+      expect(res.ok).toBe(false);
+      if (!res.ok) {
+        expect(res.code).toBe('404');
+        expect(res.message).toBe('HTTP 404');
+      }
+      // /chat/completions must NOT have been probed for an openai-responses wire.
+      expect(calls.some((c) => c.url.endsWith('/chat/completions'))).toBe(false);
     } finally {
       restore();
     }

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

@@ -42,11 +42,13 @@ export interface ConnectionTestResult {
   /**
    * `models` when the standard GET /models probe succeeded.
    * `chat_completion_degraded` when /models 404'd but POST /chat/completions
-   * proved the endpoint is alive (e.g. Zhipu GLM's gateway — no public /models
-   * but /chat/completions works fine). The renderer surfaces this so users
-   * know /models is unavailable even though generation will work.
+   * proved the openai-chat wire is alive (e.g. Zhipu GLM — no public /models).
+   * `responses_degraded` when /models 404'd but POST /responses proved the
+   * openai-responses wire is alive. We probe the wire's real inference
+   * endpoint so a gateway that only implements /chat/completions can't
+   * false-positive for a user whose provider is on the Responses API.
    */
-  probeMethod?: 'models' | 'chat_completion_degraded';
+  probeMethod?: 'models' | 'chat_completion_degraded' | 'responses_degraded';
 }
 
 export interface ConnectionTestError {
@@ -494,15 +496,19 @@ export async function runProviderTest(
     // not degrade anthropic — its /v1/models is standard, and skipping it
     // would mask real path-shape mistakes.
     if (res.status === 404 && (creds.wire === 'openai-chat' || creds.wire === 'openai-responses')) {
-      const probe = await probeChatCompletion(normalizedBaseUrl, headers);
+      const probe = await probeInferenceEndpoint(creds.wire, normalizedBaseUrl, headers);
       if (probe.kind === 'pass') {
-        return { ok: true, probeMethod: 'chat_completion_degraded' };
+        return {
+          ok: true,
+          probeMethod:
+            creds.wire === 'openai-responses' ? 'responses_degraded' : 'chat_completion_degraded',
+        };
       }
       if (probe.kind === 'http' && probe.status !== 404) {
         const { code, hint } = classifyHttpError(probe.status);
         return { ok: false, code, message: `HTTP ${probe.status}`, hint };
       }
-      // /chat/completions also 404'd (or the network dropped) — fall through
+      // Inference endpoint also 404'd (or the network dropped) — fall through
       // and report the original /models 404.
     }
     const { code, hint } = classifyHttpError(res.status);
@@ -517,28 +523,45 @@ type ProbeResult =
   | { kind: 'network'; message: string };
 
 /**
- * POST a minimal chat-completion request to verify the endpoint is alive
- * when GET /models returned 404. A 2xx response or any API-originated 4xx
- * (400 model_unknown, 402 insufficient credits, 422, 429 — and 401/403 too,
- * which we surface as an auth error instead of the misleading 404 hint)
- * counts as "endpoint reachable". Only 404 and 5xx count as a real failure.
+ * POST a minimal inference request to verify the endpoint is alive when GET
+ * /models returned 404. We dispatch by wire so that providers on the
+ * Responses API (which may not implement /chat/completions at all) can't
+ * false-positive via a gateway that only speaks the other shape. A 2xx
+ * response or any API-originated 4xx (400 model_unknown, 402 insufficient
+ * credits, 422, 429 — and 401/403 too, which we surface as auth) counts as
+ * "endpoint reachable". Only 404 and 5xx count as a real failure. The
+ * request body is intentionally minimal; if the gateway rejects the payload
+ * shape with a 4xx we still know the route exists.
  */
-async function probeChatCompletion(
+async function probeInferenceEndpoint(
+  wire: 'openai-chat' | 'openai-responses',
   normalizedBaseUrl: string,
   headers: Record<string, string>,
 ): Promise<ProbeResult> {
-  const url = `${normalizedBaseUrl}/chat/completions`;
+  const url =
+    wire === 'openai-responses'
+      ? `${normalizedBaseUrl}/responses`
+      : `${normalizedBaseUrl}/chat/completions`;
+  const body =
+    wire === 'openai-responses'
+      ? JSON.stringify({
+          model: 'probe',
+          input: [{ role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
+          max_output_tokens: 1,
+          stream: false,
+        })
+      : JSON.stringify({
+          model: 'probe',
+          messages: [{ role: 'user', content: 'ping' }],
+          max_tokens: 1,
+          stream: false,
+        });
   let res: Response;
   try {
     res = await fetchWithTimeout(url, {
       method: 'POST',
       headers: { ...headers, 'content-type': 'application/json' },
-      body: JSON.stringify({
-        model: 'probe',
-        messages: [{ role: 'user', content: 'ping' }],
-        max_tokens: 1,
-        stream: false,
-      }),
+      body,
     });
   } catch (err) {
     return { kind: 'network', message: err instanceof Error ? err.message : String(err) };