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

@@ -0,0 +1,148 @@
+// Qwen tests cover index plugin behavior.
+import {
+  registerProviderPlugin,
+  requireRegisteredProvider,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import type { ProviderCatalogResult } from "openclaw/plugin-sdk/provider-catalog-shared";
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import { describe, expect, it } from "vitest";
+import { QWEN_36_PLUS_MODEL_ID, QWEN_BASE_URL } from "./api.js";
+import qwenPlugin from "./index.js";
+import { wrapQwenProviderStream } from "./stream.js";
+
+function requireCatalogProvider(result: ProviderCatalogResult): ModelProviderConfig {
+  if (!result || !("provider" in result)) {
+    throw new Error("single provider catalog result missing");
+  }
+  return result.provider;
+}
+
+async function registerQwenProvider() {
+  const { providers } = await registerProviderPlugin({
+    plugin: qwenPlugin,
+    id: "qwen",
+    name: "Qwen Provider",
+  });
+  return requireRegisteredProvider(providers, "qwen");
+}
+
+describe("qwen provider plugin", () => {
+  it("keeps qwen3.6-plus out of Coding Plan normalized catalogs", async () => {
+    const provider = await registerQwenProvider();
+
+    const normalized = provider.normalizeConfig?.({
+      provider: "qwen",
+      providerConfig: {
+        baseUrl: QWEN_BASE_URL,
+        models: [{ id: "qwen3.5-plus" }, { id: QWEN_36_PLUS_MODEL_ID }],
+      },
+    } as never);
+
+    expect(normalized?.models?.map((model) => model.id)).toEqual(["qwen3.5-plus"]);
+  });
+
+  it("does not expose runtime model suppression hooks", async () => {
+    const provider = await registerQwenProvider();
+
+    expect(provider.suppressBuiltInModel).toBeUndefined();
+  });
+
+  it("registers qwen-oauth as a portal provider", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: qwenPlugin,
+      id: "qwen",
+      name: "Qwen Provider",
+    });
+    const provider = requireRegisteredProvider(providers, "qwen-oauth");
+
+    expect(provider.aliases).toEqual(["qwen-portal", "qwen-cli"]);
+    expect(provider.envVars).toEqual(["QWEN_API_KEY"]);
+    expect(provider.auth?.map((method) => method.id)).toEqual(["api-key"]);
+
+    const result = await provider.staticCatalog?.run({
+      config: {},
+      env: {},
+      resolveProviderApiKey: () => ({}),
+    } as never);
+    const catalogProvider = requireCatalogProvider(result);
+    expect(catalogProvider.baseUrl).toBe("https://portal.qwen.ai/v1");
+    expect(catalogProvider.models?.map((model) => model.id)).toContain("qwen3.5-plus");
+  });
+
+  it("reuses legacy qwen portal auth profiles for qwen-oauth catalog", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: qwenPlugin,
+      id: "qwen",
+      name: "Qwen Provider",
+    });
+    const provider = requireRegisteredProvider(providers, "qwen-oauth");
+
+    const result = await provider.catalog?.run({
+      config: {},
+      env: {},
+      resolveProviderApiKey: (providerId: string) =>
+        providerId === "qwen-portal" ? { apiKey: "portal-token" } : {},
+    } as never);
+
+    const catalogProvider = requireCatalogProvider(result);
+    expect(catalogProvider.apiKey).toBe("portal-token");
+    expect(catalogProvider.baseUrl).toBe("https://portal.qwen.ai/v1");
+  });
+
+  it.each([["qwen-oauth"], ["qwen-portal"], ["qwen-cli"]])(
+    "patches %s message payloads for portal compatibility",
+    async (providerId) => {
+      let patchedPayload: Record<string, unknown> | undefined;
+      const streamFn = wrapQwenProviderStream({
+        provider: providerId,
+        thinkingLevel: "off",
+        streamFn: ((
+          _model: unknown,
+          _context: unknown,
+          options?: {
+            onPayload?: (payload: Record<string, unknown>, model: unknown) => void;
+          },
+        ) => {
+          const payload = {
+            messages: [
+              { role: "system", content: "system text" },
+              { role: "user", content: ["hello", { type: "text", text: "world" }] },
+            ],
+          };
+          options?.onPayload?.(payload, _model);
+          patchedPayload = payload;
+          return (async function* () {})();
+        }) as never,
+      } as never);
+
+      const stream = streamFn!(
+        {
+          provider: providerId,
+          api: "openai-completions",
+          id: "qwen3.5-plus",
+        } as never,
+        {} as never,
+        {},
+      ) as AsyncIterable<unknown>;
+      for await (const event of stream) {
+        void event;
+        // Drain stream so the payload hook runs.
+      }
+
+      expect(patchedPayload?.vl_high_resolution_images).toBe(true);
+      expect(patchedPayload?.messages).toEqual([
+        {
+          role: "system",
+          content: [{ type: "text", text: "system text", cache_control: { type: "ephemeral" } }],
+        },
+        {
+          role: "user",
+          content: [
+            { type: "text", text: "hello" },
+            { type: "text", text: "world" },
+          ],
+        },
+      ]);
+    },
+  );
+});