@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/node-env-runtime.test.ts

@@ -0,0 +1,98 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+// `bun build --compile` inlines `process.env.NODE_ENV` dot reads as
+// "development". Compile a tiny entry with the API Dockerfile's flags and
+// check that the SSRF guards (public endpoints and MCP OAuth) and `getNodeEnv`
+// see the runtime value.
+// scripts/check-node-env-access.sh keeps new dot reads out of src/.
+
+const SRC = resolve(import.meta.dir, "..");
+
+let dir: string;
+let binary: string;
+
+function runBinary(nodeEnv: string | undefined) {
+  const env: Record<string, string | undefined> = { ...process.env };
+  delete env.NODE_ENV;
+  delete env.ALLOW_PRIVATE_NETWORK_URLS;
+  if (nodeEnv !== undefined) env.NODE_ENV = nodeEnv;
+  return runChild([binary], { env }).then((r) => JSON.parse(expectChildOk(r, binary).stdout));
+}
+
+describe("NODE_ENV in compiled binaries", () => {
+  beforeAll(async () => {
+    dir = await mkdtemp(join(tmpdir(), "node-env-compile-"));
+    const entry = join(dir, "entry.ts");
+    binary = join(dir, "entry-bin");
+    await Bun.write(
+      entry,
+      [
+        `import { assertUrlSafe, discoverAuthorizationServerMetadata, mcpOAuthSsrfOptions, publicEndpointSsrfOptions } from ${JSON.stringify(join(SRC, "oauth/mcp-wrapper.ts"))};`,
+        `import { getNodeEnv } from ${JSON.stringify(join(SRC, "utils/node-env.ts"))};`,
+        // The guard src/http/mcp-oauth.ts applies to stored and discovered endpoints.
+        "let routeGuardAllowsHttp = true;",
+        'try { assertUrlSafe("http://example.com/mcp", mcpOAuthSsrfOptions()); } catch { routeGuardAllowsHttp = false; }',
+        // safeFetch in mcp-wrapper.ts: count fetches reaching the network.
+        "let fetches = 0;",
+        'globalThis.fetch = (async () => { fetches++; return Response.json({ issuer: "http://example.com" }); }) as typeof fetch;',
+        'await discoverAuthorizationServerMetadata("http://example.com").catch(() => {});',
+        "console.log(JSON.stringify({ nodeEnv: getNodeEnv() ?? null, ssrf: publicEndpointSsrfOptions(), oauthHttp: { routeGuardAllowsHttp, fetches } }));",
+      ].join("\n"),
+    );
+    // Same flags as the API binary in Dockerfile.
+    const build = await runChild([
+      process.execPath,
+      "build",
+      entry,
+      "--compile",
+      "--compile-exec-argv=--expose-gc",
+      "--outfile",
+      binary,
+    ]);
+    expectChildOk(build, "bun build --compile");
+  }, CHILD_PROCESS_TEST_BUDGET_MS);
+
+  afterAll(async () => {
+    if (dir) await rm(dir, { recursive: true, force: true });
+  });
+
+  test(
+    "NODE_ENV unset: the SSRF guards block private and insecure endpoints, including MCP OAuth",
+    async () => {
+      expect(await runBinary(undefined)).toEqual({
+        nodeEnv: null,
+        ssrf: { allowPrivateHosts: false, allowInsecure: false },
+        oauthHttp: { routeGuardAllowsHttp: false, fetches: 0 },
+      });
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "NODE_ENV=production is seen at runtime",
+    async () => {
+      expect(await runBinary("production")).toEqual({
+        nodeEnv: "production",
+        ssrf: { allowPrivateHosts: false, allowInsecure: false },
+        oauthHttp: { routeGuardAllowsHttp: false, fetches: 0 },
+      });
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "NODE_ENV=development still opens the guard",
+    async () => {
+      expect(await runBinary("development")).toEqual({
+        nodeEnv: "development",
+        ssrf: { allowPrivateHosts: true, allowInsecure: true },
+        oauthHttp: { routeGuardAllowsHttp: true, fetches: 1 },
+      });
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/openai-compatible-providers.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "bun:test";
+import {
+  baseUrlEnvVar,
+  OPENAI_COMPATIBLE_PROVIDERS,
+  openAICompatibleProviderIds,
+  providerBaseUrl,
+  providerForKeyVar,
+  providerForModel,
+  providerKeyFromEnv,
+  withRegistryCatalogSections,
+} from "@desplega/model-catalog";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import snapshot from "../be/modelsdev-cache.json";
+import { normalizeProviderKeyAliases } from "../utils/credentials";
+
+type SnapshotModel = {
+  name: string;
+  reasoning?: boolean;
+  tool_call?: boolean;
+  modalities?: { input?: string[] };
+  limit?: { context?: number; output?: number };
+};
+type SnapshotProvider = {
+  api?: string;
+  env?: string[];
+  npm?: string;
+  models: Record<string, SnapshotModel>;
+};
+
+describe("openai-compatible provider table", () => {
+  test("providerForModel routes by exact prefix only", () => {
+    expect(providerForModel("nan/glm5.3-flash")?.id).toBe("nan");
+    expect(providerForModel("helmcode/gemma4")?.id).toBe("helmcode");
+    expect(providerForModel("openrouter/nan/glm5.3")).toBeUndefined();
+    expect(providerForModel("glm5.3")).toBeUndefined();
+    expect(providerForModel("nanx/glm5.3")).toBeUndefined();
+    expect(providerForModel("toString/x")).toBeUndefined();
+    expect(providerForModel(undefined)).toBeUndefined();
+  });
+
+  test("providerForKeyVar finds canonical and alias key vars", () => {
+    expect(providerForKeyVar("NAN_API_KEY")?.id).toBe("nan");
+    expect(providerForKeyVar("HELMCODE_API_NAN")?.id).toBe("nan");
+    expect(providerForKeyVar("HELMCODE_API_KEY")?.id).toBe("helmcode");
+    expect(providerForKeyVar("OPENROUTER_API_KEY")).toBeUndefined();
+  });
+
+  test("<ID>_BASE_URL overrides the default base URL", () => {
+    const nan = OPENAI_COMPATIBLE_PROVIDERS.nan;
+    const helmcode = OPENAI_COMPATIBLE_PROVIDERS.helmcode;
+    expect(baseUrlEnvVar(nan)).toBe("NAN_BASE_URL");
+    expect(baseUrlEnvVar(helmcode)).toBe("HELMCODE_BASE_URL");
+    expect(providerBaseUrl(nan, {})).toBe("https://api.nan.builders/v1");
+    expect(providerBaseUrl(nan, { NAN_BASE_URL: "  " })).toBe("https://api.nan.builders/v1");
+    expect(providerBaseUrl(helmcode, { HELMCODE_BASE_URL: "http://127.0.0.1:9/v1/" })).toBe(
+      "http://127.0.0.1:9/v1",
+    );
+  });
+
+  test("providerKeyFromEnv prefers the canonical var, then the alias", () => {
+    const nan = OPENAI_COMPATIBLE_PROVIDERS.nan;
+    expect(providerKeyFromEnv(nan, { HELMCODE_API_NAN: "alias" })).toBe("alias");
+    expect(providerKeyFromEnv(nan, { NAN_API_KEY: "canon", HELMCODE_API_NAN: "alias" })).toBe(
+      "canon",
+    );
+    expect(providerKeyFromEnv(nan, { NAN_API_KEY: "  " })).toBeUndefined();
+    expect(providerKeyFromEnv(OPENAI_COMPATIBLE_PROVIDERS.helmcode, { NAN_API_KEY: "k" })).toBe(
+      undefined,
+    );
+  });
+
+  test("normalizeProviderKeyAliases copies an alias only into an empty canonical var", () => {
+    const aliasOnly: Record<string, string | undefined> = { HELMCODE_API_NAN: "alias" };
+    normalizeProviderKeyAliases(aliasOnly);
+    expect(aliasOnly.NAN_API_KEY).toBe("alias");
+    const both: Record<string, string | undefined> = {
+      NAN_API_KEY: "canon",
+      HELMCODE_API_NAN: "alias",
+    };
+    normalizeProviderKeyAliases(both);
+    expect(both.NAN_API_KEY).toBe("canon");
+  });
+
+  test("registry-sourced sections are synthesized, never hand-written in the snapshot", () => {
+    const raw = snapshot as unknown as Record<string, unknown>;
+    for (const id of openAICompatibleProviderIds()) {
+      const entry = OPENAI_COMPATIBLE_PROVIDERS[id];
+      if (entry.catalog === "registry") expect(raw[id]).toBeUndefined();
+      else expect(raw[id]).toBeDefined();
+    }
+    // The server loader carries the synthesized sections.
+    expect(loadModelsDevCache()?.helmcode?.models?.["glm5.3"]?.limit?.context).toBe(1048576);
+  });
+
+  // The registry duplicates the models.dev sections of `catalog: "models.dev"`
+  // entries (the pi/opencode blocks need limits the worker cannot read from
+  // the catalog store); keep the two from drifting. Registry-sourced sections
+  // are built from the registry, so they agree by construction.
+  const merged = withRegistryCatalogSections(
+    snapshot as unknown as Record<string, SnapshotProvider | undefined>,
+  );
+  for (const id of openAICompatibleProviderIds()) {
+    test(`${id} matches its catalog section`, () => {
+      const entry = OPENAI_COMPATIBLE_PROVIDERS[id];
+      const section = merged[id];
+      expect(section).toBeDefined();
+      if (!section) return;
+      // OpenCode's built-in AI Gateway SDK has no OpenAI-compatible `api` URL.
+      if (entry.npm === "@ai-sdk/gateway") expect(section.api).toBeUndefined();
+      else expect(section.api).toBe(entry.baseUrl);
+      expect(section.env).toEqual([entry.envVar]);
+      expect(section.npm).toBe(entry.npm);
+      for (const model of entry.models) {
+        const snap = section.models[model.id];
+        expect(snap, `${id}/${model.id} missing from snapshot`).toBeDefined();
+        if (!snap) continue;
+        expect({
+          name: model.name,
+          contextWindow: model.contextWindow,
+          maxOutputTokens: model.maxOutputTokens,
+          reasoning: model.reasoning,
+          input: [...model.input],
+        }).toEqual({
+          name: snap.name,
+          contextWindow: snap.limit?.context,
+          maxOutputTokens: snap.limit?.output,
+          reasoning: snap.reasoning,
+          input: (snap.modalities?.input ?? []).filter((m) => m === "text" || m === "image"),
+        });
+        expect(snap.tool_call).toBe(true);
+      }
+    });
+  }
+});

package/src/tests/openai-compatible-registry-extension.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Proof that adding an OpenAI-compatible provider takes one registry entry:
+ * a fake `testgw` entry must reach every derived surface
+ * (`fixtures/openai-compatible-registry-extension.child.ts`).
+ *
+ * The proof mocks the registry module, and its consumers cache derivations of
+ * the table at import (integration cards, picker constants) that no mock
+ * restore can undo. It runs in its own `bun test` child so this process, and
+ * every file sharing it in a single-process run, keeps the real table.
+ */
+import { expect, test } from "bun:test";
+import { join } from "node:path";
+import { modelGroupsForHarness } from "../../apps/ui/src/lib/agent-runtime-models";
+import { INTEGRATIONS } from "../../apps/ui/src/lib/integrations-catalog";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+const REPO_ROOT = join(import.meta.dir, "../..");
+const CHILD = "./src/tests/fixtures/openai-compatible-registry-extension.child.ts";
+
+test(
+  "a testgw registry entry reaches every derived surface (child process)",
+  async () => {
+    const result = expectChildOk(
+      await runChild([process.execPath, "test", CHILD], {
+        cwd: REPO_ROOT,
+        env: { ...process.env },
+      }),
+      "registry extension proof",
+    );
+    // bun test reports to stderr; 0 fail and every case ran.
+    const report = `${result.stdout}\n${result.stderr}`;
+    expect(report).toMatch(/\b6 pass\b/);
+    expect(report).toMatch(/\b0 fail\b/);
+  },
+  CHILD_PROCESS_TEST_BUDGET_MS,
+);
+
+test("this process still sees the real registry only", () => {
+  expect(INTEGRATIONS.some((def) => def.id === "testgw")).toBe(false);
+  const providers = modelGroupsForHarness("pi", [], {}).map((g) => g.provider);
+  expect(providers).not.toContain("TestGW");
+});