Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/vercel-ai-gateway/provider-catalog.test.ts

@@ -0,0 +1,189 @@
+// Vercel Ai Gateway tests cover provider catalog plugin behavior.
+import { clearLiveCatalogCacheForTests } from "openclaw/plugin-sdk/provider-catalog-live-runtime";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { fetchWithSsrFGuardMock } = vi.hoisted(() => ({
+  fetchWithSsrFGuardMock: vi.fn(),
+}));
+
+vi.mock("openclaw/plugin-sdk/ssrf-runtime", () => ({
+  fetchWithSsrFGuard: fetchWithSsrFGuardMock,
+  ssrfPolicyFromHttpBaseUrlAllowedHostname: (baseUrl: string) => ({
+    allowedHostnames: [new URL(baseUrl).hostname],
+  }),
+}));
+
+import {
+  discoverVercelAiGatewayModels,
+  getStaticVercelAiGatewayModelCatalog,
+  VERCEL_AI_GATEWAY_BASE_URL,
+  VERCEL_AI_GATEWAY_DEFAULT_CONTEXT_WINDOW,
+  VERCEL_AI_GATEWAY_DEFAULT_MAX_TOKENS,
+} from "./api.js";
+import { resolveVercelAiGatewayDynamicModel } from "./models.js";
+import {
+  buildStaticVercelAiGatewayProvider,
+  buildVercelAiGatewayProvider,
+  resolveVercelAiGatewayModel,
+} from "./provider-catalog.js";
+
+const STATIC_MODEL_IDS = [
+  "anthropic/claude-opus-4.6",
+  "openai/gpt-5.4",
+  "openai/gpt-5.4-pro",
+  "moonshotai/kimi-k2.6",
+];
+
+function restoreEnvVar(name: "NODE_ENV" | "VITEST", value: string | undefined): void {
+  if (value === undefined) {
+    delete process.env[name];
+  } else {
+    process.env[name] = value;
+  }
+}
+
+async function withLiveDiscovery<T>(run: () => Promise<T>): Promise<T> {
+  const oldNodeEnv = process.env.NODE_ENV;
+  const oldVitest = process.env.VITEST;
+  delete process.env.NODE_ENV;
+  delete process.env.VITEST;
+  try {
+    return await run();
+  } finally {
+    restoreEnvVar("NODE_ENV", oldNodeEnv);
+    restoreEnvVar("VITEST", oldVitest);
+  }
+}
+
+function jsonResponse(payload: unknown, init: ResponseInit = {}): Response {
+  return new Response(JSON.stringify(payload), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    ...init,
+  });
+}
+
+afterEach(() => {
+  clearLiveCatalogCacheForTests();
+  fetchWithSsrFGuardMock.mockReset();
+});
+
+describe("vercel ai gateway provider catalog", () => {
+  it("builds the bundled Vercel AI Gateway defaults", async () => {
+    const provider = await buildVercelAiGatewayProvider();
+
+    expect(provider).toStrictEqual({
+      baseUrl: VERCEL_AI_GATEWAY_BASE_URL,
+      api: "anthropic-messages",
+      models: getStaticVercelAiGatewayModelCatalog(),
+    });
+  });
+
+  it("exposes the static fallback model catalog", () => {
+    expect(getStaticVercelAiGatewayModelCatalog().map((model) => model.id)).toStrictEqual(
+      STATIC_MODEL_IDS,
+    );
+  });
+
+  it("builds an offline static provider catalog", () => {
+    expect(buildStaticVercelAiGatewayProvider()).toStrictEqual({
+      baseUrl: VERCEL_AI_GATEWAY_BASE_URL,
+      api: "anthropic-messages",
+      models: getStaticVercelAiGatewayModelCatalog(),
+    });
+  });
+
+  it("builds runtime metadata for live-only model ids", () => {
+    expect(resolveVercelAiGatewayDynamicModel("custom/provider-model")).toEqual({
+      id: "custom/provider-model",
+      name: "custom/provider-model",
+      reasoning: false,
+      input: ["text"],
+      contextWindow: VERCEL_AI_GATEWAY_DEFAULT_CONTEXT_WINDOW,
+      maxTokens: VERCEL_AI_GATEWAY_DEFAULT_MAX_TOKENS,
+      cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+      },
+    });
+  });
+
+  it("adds transport metadata for runtime model resolution", () => {
+    expect(resolveVercelAiGatewayModel("custom/provider-model")).toMatchObject({
+      id: "custom/provider-model",
+      provider: "vercel-ai-gateway",
+      api: "anthropic-messages",
+      baseUrl: VERCEL_AI_GATEWAY_BASE_URL,
+    });
+  });
+
+  it("preserves provider thinking metadata for known live-only upstream models", () => {
+    expect(resolveVercelAiGatewayModel("openai/gpt-5.5")).toMatchObject({
+      reasoning: true,
+      input: ["text", "image"],
+    });
+    expect(resolveVercelAiGatewayModel("anthropic/claude-sonnet-4-6")).toMatchObject({
+      input: ["text", "image"],
+    });
+  });
+
+  it("falls back to the static catalog for malformed successful model list payloads", async () => {
+    for (const payload of [[], { data: {} }, { data: [null] }]) {
+      clearLiveCatalogCacheForTests();
+      fetchWithSsrFGuardMock.mockReset();
+      fetchWithSsrFGuardMock.mockResolvedValueOnce({
+        response: jsonResponse(payload),
+        release: async () => {},
+        finalUrl: `${VERCEL_AI_GATEWAY_BASE_URL}/v1/models`,
+      });
+
+      await withLiveDiscovery(async () => {
+        expect(await discoverVercelAiGatewayModels()).toStrictEqual(
+          getStaticVercelAiGatewayModelCatalog(),
+        );
+      });
+    }
+  });
+
+  it("falls back from malformed live token metadata", async () => {
+    fetchWithSsrFGuardMock.mockResolvedValueOnce({
+      response: jsonResponse({
+        data: [
+          {
+            id: "anthropic/claude-opus-4.6",
+            name: "Claude Opus 4.6",
+            context_window: -1,
+            max_tokens: 128_000.5,
+            tags: ["vision", "reasoning"],
+          },
+          {
+            id: "custom/provider-model",
+            name: "Custom model",
+            context_window: Number.POSITIVE_INFINITY,
+            max_tokens: 0,
+            tags: ["reasoning"],
+          },
+        ],
+      }),
+      release: async () => {},
+      finalUrl: `${VERCEL_AI_GATEWAY_BASE_URL}/v1/models`,
+    });
+
+    await withLiveDiscovery(async () => {
+      const models = await discoverVercelAiGatewayModels();
+
+      expect(models[0]).toMatchObject({
+        id: "anthropic/claude-opus-4.6",
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+      });
+      expect(models[1]).toMatchObject({
+        id: "custom/provider-model",
+        contextWindow: VERCEL_AI_GATEWAY_DEFAULT_CONTEXT_WINDOW,
+        maxTokens: VERCEL_AI_GATEWAY_DEFAULT_MAX_TOKENS,
+      });
+    });
+  });
+});