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/arcee/index.test.ts

@@ -0,0 +1,196 @@
+// Arcee tests cover index plugin behavior.
+import {
+  registerSingleProviderPlugin,
+  resolveProviderPluginChoice,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import { resolveProviderAuthEnvVarCandidates } from "openclaw/plugin-sdk/provider-env-vars";
+import { describe, expect, it } from "vitest";
+import { runSingleProviderCatalog } from "../test-support/provider-model-test-helpers.js";
+import arceePlugin from "./index.js";
+
+describe("arcee provider plugin", () => {
+  it("registers Arcee AI with direct and OpenRouter auth choices", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    expect(provider.id).toBe("arcee");
+    expect(provider.label).toBe("Arcee AI");
+    expect(provider.envVars).toEqual(["ARCEEAI_API_KEY", "OPENROUTER_API_KEY"]);
+    expect(provider.auth).toHaveLength(2);
+
+    const directChoice = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "arceeai-api-key",
+    });
+    if (!directChoice) {
+      throw new Error("expected direct Arcee auth choice");
+    }
+    expect(directChoice.provider.id).toBe("arcee");
+    expect(directChoice.method.id).toBe("arcee-platform");
+
+    const orChoice = resolveProviderPluginChoice({
+      providers: [provider],
+      choice: "arceeai-openrouter",
+    });
+    if (!orChoice) {
+      throw new Error("expected OpenRouter Arcee auth choice");
+    }
+    expect(orChoice.provider.id).toBe("arcee");
+    expect(orChoice.method.id).toBe("openrouter");
+  });
+
+  it("stores the OpenRouter onboarding path under the OpenRouter auth profile", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+    const openRouterMethod = provider.auth?.find((method) => method.id === "openrouter");
+    if (!openRouterMethod?.runNonInteractive) {
+      throw new Error("expected OpenRouter non-interactive auth");
+    }
+
+    const config = await openRouterMethod.runNonInteractive({
+      config: {},
+      opts: {},
+      env: {},
+      runtime: {
+        error: () => {},
+        exit: () => {},
+        log: () => {},
+      },
+      resolveApiKey: async () => ({
+        key: "sk-or-test",
+        source: "profile",
+      }),
+      toApiKeyCredential: () => null,
+    } as never);
+
+    const openRouterProfile = config?.auth?.profiles?.["openrouter:default"];
+    expect(openRouterProfile?.provider).toBe("openrouter");
+    expect(openRouterProfile?.mode).toBe("api_key");
+    const arceeConfig = config?.models?.providers?.arcee;
+    expect(arceeConfig?.baseUrl).toBe("https://openrouter.ai/api/v1");
+    expect(arceeConfig?.api).toBe("openai-completions");
+    expect(config?.models?.providers?.arcee?.models?.map((model) => model.id)).toEqual([
+      "arcee/trinity-mini",
+      "arcee/trinity-large-preview",
+      "arcee/trinity-large-thinking",
+    ]);
+  });
+
+  it("keeps direct Arcee auth env candidates separate from OpenRouter", () => {
+    const candidates = resolveProviderAuthEnvVarCandidates();
+
+    expect(candidates.arcee).toEqual(["ARCEEAI_API_KEY"]);
+    expect(candidates.openrouter).toEqual(["OPENROUTER_API_KEY"]);
+  });
+
+  it("builds the direct Arcee AI model catalog", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+    const catalogProvider = await runSingleProviderCatalog(provider, {
+      resolveProviderApiKey: (id?: string) =>
+        id === "arcee" ? { apiKey: "test-key" } : { apiKey: undefined },
+    });
+
+    expect(catalogProvider.api).toBe("openai-completions");
+    expect(catalogProvider.baseUrl).toBe("https://api.arcee.ai/api/v1");
+    expect(catalogProvider.models?.map((model) => model.id)).toEqual([
+      "trinity-mini",
+      "trinity-large-preview",
+      "trinity-large-thinking",
+    ]);
+    const thinkingCompat = catalogProvider.models?.find(
+      (model) => model.id === "trinity-large-thinking",
+    )?.compat;
+    expect(thinkingCompat?.supportsTools).toBe(false);
+    expect(thinkingCompat?.supportsReasoningEffort).toBe(false);
+  });
+
+  it("builds the OpenRouter-backed Arcee AI model catalog", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+    const catalogProvider = await runSingleProviderCatalog(provider, {
+      resolveProviderApiKey: (id?: string) =>
+        id === "openrouter" ? { apiKey: "sk-or-test" } : { apiKey: undefined },
+      resolveProviderAuth: () => ({
+        apiKey: "sk-or-test",
+        mode: "api_key",
+        source: "env",
+      }),
+    });
+
+    expect(catalogProvider.baseUrl).toBe("https://openrouter.ai/api/v1");
+    expect(catalogProvider.models?.map((model) => model.id)).toEqual([
+      "arcee/trinity-mini",
+      "arcee/trinity-large-preview",
+      "arcee/trinity-large-thinking",
+    ]);
+    const thinkingCompat = catalogProvider.models?.find(
+      (model) => model.id === "arcee/trinity-large-thinking",
+    )?.compat;
+    expect(thinkingCompat?.supportsTools).toBe(false);
+    expect(thinkingCompat?.supportsReasoningEffort).toBe(false);
+  });
+
+  it("normalizes Arcee OpenRouter models to vendor-prefixed runtime ids", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    const openRouterModel = provider.normalizeResolvedModel?.({
+      modelId: "arcee/trinity-large-thinking",
+      model: {
+        provider: "arcee",
+        id: "trinity-large-thinking",
+        name: "Trinity Large Thinking",
+        api: "openai-completions",
+        baseUrl: "https://openrouter.ai/api/v1",
+      },
+    } as never);
+    expect(openRouterModel?.id).toBe("arcee/trinity-large-thinking");
+
+    expect(
+      provider.normalizeResolvedModel?.({
+        modelId: "arcee/trinity-large-thinking",
+        model: {
+          provider: "arcee",
+          id: "trinity-large-thinking",
+          name: "Trinity Large Thinking",
+          api: "openai-completions",
+          baseUrl: "https://api.arcee.ai/api/v1",
+        },
+      } as never),
+    ).toBeUndefined();
+  });
+
+  it("canonicalizes stale OpenRouter /v1 config and transport metadata", async () => {
+    const provider = await registerSingleProviderPlugin(arceePlugin);
+
+    const normalizedConfig = provider.normalizeConfig?.({
+      provider: "arcee",
+      providerConfig: {
+        api: "openai-completions",
+        baseUrl: "https://openrouter.ai/v1/",
+        models: [],
+      },
+    } as never);
+    expect(normalizedConfig?.baseUrl).toBe("https://openrouter.ai/api/v1");
+
+    const normalizedModel = provider.normalizeResolvedModel?.({
+      modelId: "arcee/trinity-large-thinking",
+      model: {
+        provider: "arcee",
+        id: "trinity-large-thinking",
+        name: "Trinity Large Thinking",
+        api: "openai-completions",
+        baseUrl: "https://openrouter.ai/v1",
+      },
+    } as never);
+    expect(normalizedModel?.id).toBe("arcee/trinity-large-thinking");
+    expect(normalizedModel?.baseUrl).toBe("https://openrouter.ai/api/v1");
+
+    expect(
+      provider.normalizeTransport?.({
+        provider: "arcee",
+        api: "openai-completions",
+        baseUrl: "https://openrouter.ai/v1",
+      } as never),
+    ).toEqual({
+      api: "openai-completions",
+      baseUrl: "https://openrouter.ai/api/v1",
+    });
+  });
+});