[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/providerConnectionProbe.test.ts

@@ -0,0 +1,210 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  buildProviderProbeUrl,
+  classifyProviderProbeResponse,
+  probeProviderConnection,
+  resolveProviderProbeEndpoint,
+  validateProviderProbeInputs,
+} from "./providerConnectionProbe";
+
+test("resolveProviderProbeEndpoint follows style conventions including Google /models", () => {
+  assert.equal(resolveProviderProbeEndpoint("openai"), "/models");
+  assert.equal(resolveProviderProbeEndpoint("anthropic"), "/v1/models");
+  assert.equal(resolveProviderProbeEndpoint("google"), "/models");
+  assert.equal(resolveProviderProbeEndpoint("openai", "/custom"), "/models");
+  assert.equal(resolveProviderProbeEndpoint("google", "/custom/list"), "/models");
+});
+
+test("buildProviderProbeUrl joins base URL and endpoint without duplicate slashes", () => {
+  assert.equal(
+    buildProviderProbeUrl("https://api.deepseek.com/v1/", "/models"),
+    "https://api.deepseek.com/v1/models",
+  );
+  assert.equal(
+    buildProviderProbeUrl("https://api.anthropic.com", "/v1/models"),
+    "https://api.anthropic.com/v1/models",
+  );
+});
+
+test("buildProviderProbeUrl avoids double /v1 for AI SDK style Anthropic bases", () => {
+  // Reporter case: Base URL already includes /v1 (chat works) but probe used to
+  // request GET …/v1/v1/models.
+  assert.equal(
+    buildProviderProbeUrl("https://gateway.example/v1", "/v1/models"),
+    "https://gateway.example/v1/models",
+  );
+  assert.equal(
+    buildProviderProbeUrl("https://gateway.example/v1/", "/v1/models"),
+    "https://gateway.example/v1/models",
+  );
+  assert.equal(
+    buildProviderProbeUrl("https://gateway.example/", "/v1/models"),
+    "https://gateway.example/v1/models",
+  );
+});
+
+test("validateProviderProbeInputs requires base URL and API key except for ollama", () => {
+  assert.deepEqual(
+    validateProviderProbeInputs({ baseURL: "", apiKey: "sk", providerId: "openai" }),
+    { ok: false, reason: "missing_base_url" },
+  );
+  assert.deepEqual(
+    validateProviderProbeInputs({ baseURL: "https://api.openai.com/v1", apiKey: "", providerId: "openai" }),
+    { ok: false, reason: "missing_api_key" },
+  );
+  assert.deepEqual(
+    validateProviderProbeInputs({ baseURL: "http://localhost:11434/v1", apiKey: "", providerId: "ollama" }),
+    { ok: true },
+  );
+});
+
+test("classifyProviderProbeResponse marks auth and transport failures as error", () => {
+  assert.equal(
+    classifyProviderProbeResponse({ ok: false, status: 401, latencyMs: 120, error: "Unauthorized" }).health,
+    "error",
+  );
+  assert.equal(
+    classifyProviderProbeResponse({ ok: false, status: 0, latencyMs: 30, error: "Request timeout" }).health,
+    "error",
+  );
+});
+
+test("classifyProviderProbeResponse marks 2xx with models payload as ok", () => {
+  const result = classifyProviderProbeResponse({
+    ok: true,
+    status: 200,
+    latencyMs: 180,
+    data: JSON.stringify({ data: [{ id: "deepseek-chat" }] }),
+  });
+  assert.equal(result.health, "ok");
+  assert.equal(result.latencyMs, 180);
+  assert.equal(result.statusCode, 200);
+  assert.equal(result.modelCount, 1);
+});
+
+test("classifyProviderProbeResponse marks slow or empty success as warn", () => {
+  assert.equal(
+    classifyProviderProbeResponse({
+      ok: true,
+      status: 200,
+      latencyMs: 4500,
+      data: JSON.stringify({ data: [{ id: "m" }] }),
+      slowThresholdMs: 3000,
+    }).health,
+    "warn",
+  );
+  assert.equal(
+    classifyProviderProbeResponse({
+      ok: true,
+      status: 200,
+      latencyMs: 100,
+      data: JSON.stringify({ data: [] }),
+    }).health,
+    "warn",
+  );
+});
+
+test("classifyProviderProbeResponse accepts Google ListModels name-only entries", () => {
+  const result = classifyProviderProbeResponse({
+    ok: true,
+    status: 200,
+    latencyMs: 220,
+    data: JSON.stringify({ models: [{ name: "models/gemini-2.0-flash" }] }),
+  });
+  assert.equal(result.health, "ok");
+  assert.equal(result.modelCount, 1);
+});
+
+test("probeProviderConnection orchestrates allowlist, headers, fetch, and classification", async () => {
+  const calls: Array<{
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    skipTLSVerify?: boolean;
+  }> = [];
+  const allowlist: string[] = [];
+  let clock = 1_000;
+  const run = await probeProviderConnection({
+    bridge: {
+      aiAllowlistAddHost: async (baseURL) => {
+        allowlist.push(baseURL);
+        return { ok: true };
+      },
+      aiFetch: async (url, method, headers, _body, _providerId, _skipHostCheck, _followRedirects, skipTLSVerify) => {
+        calls.push({ url, method, headers, skipTLSVerify });
+        return {
+          ok: true,
+          status: 200,
+          data: JSON.stringify({ data: [{ id: "deepseek-chat" }] }),
+        };
+      },
+    },
+    baseURL: "https://api.deepseek.com/v1/",
+    apiKey: "sk-test",
+    providerId: "openai",
+    style: "openai",
+    skipTLSVerify: true,
+    now: () => {
+      clock += 150;
+      return clock;
+    },
+  });
+
+  assert.deepEqual(allowlist, ["https://api.deepseek.com/v1/"]);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0]?.url, "https://api.deepseek.com/v1/models");
+  assert.equal(calls[0]?.method, "GET");
+  assert.equal(calls[0]?.skipTLSVerify, true);
+  assert.deepEqual(calls[0]?.headers, { Authorization: "Bearer sk-test" });
+  assert.equal(run.ok, true);
+  if (!run.ok) throw new Error("expected probe success");
+  assert.equal(run.classification.health, "ok");
+  assert.equal(run.classification.latencyMs, 150);
+  assert.equal(run.classification.modelCount, 1);
+});
+
+test("probeProviderConnection returns typed failures before fetch", async () => {
+  assert.deepEqual(
+    await probeProviderConnection({
+      bridge: { aiFetch: async () => ({ ok: true, status: 200, data: "{}" }) },
+      baseURL: "",
+      apiKey: "sk",
+      providerId: "openai",
+      style: "openai",
+    }),
+    { ok: false, reason: "missing_base_url" },
+  );
+  assert.deepEqual(
+    await probeProviderConnection({
+      bridge: undefined,
+      baseURL: "https://api.openai.com/v1",
+      apiKey: "sk",
+      providerId: "openai",
+      style: "openai",
+    }),
+    { ok: false, reason: "unavailable" },
+  );
+});
+
+test("probeProviderConnection does not double /v1 for Anthropic AI SDK style bases", async () => {
+  const calls: string[] = [];
+  const run = await probeProviderConnection({
+    bridge: {
+      aiFetch: async (url) => {
+        calls.push(url);
+        return {
+          ok: true,
+          status: 200,
+          data: JSON.stringify({ data: [{ id: "claude-sonnet" }] }),
+        };
+      },
+    },
+    baseURL: "https://gateway.example/v1",
+    apiKey: "sk-test",
+    providerId: "custom",
+    style: "anthropic",
+  });
+  assert.deepEqual(calls, ["https://gateway.example/v1/models"]);
+  assert.equal(run.ok, true);
+});