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

@@ -0,0 +1,15 @@
+/**
+ * Alibaba Model Studio plugin entry. Registers the DashScope-backed video
+ * generation provider.
+ */
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { buildAlibabaVideoGenerationProvider } from "./video-generation-provider.js";
+
+export default definePluginEntry({
+  id: "alibaba",
+  name: "Alibaba Model Studio Plugin",
+  description: "Bundled Alibaba Model Studio video provider plugin",
+  register(api) {
+    api.registerVideoGenerationProvider(buildAlibabaVideoGenerationProvider());
+  },
+});

extensions/alibaba/openclaw.plugin.json

@@ -0,0 +1,40 @@
+{
+  "id": "alibaba",
+  "icon": "https://cdn.simpleicons.org/alibabacloud",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "setup": {
+    "providers": [
+      {
+        "id": "alibaba",
+        "envVars": ["MODELSTUDIO_API_KEY", "DASHSCOPE_API_KEY", "QWEN_API_KEY"]
+      }
+    ]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "alibaba",
+      "method": "api-key",
+      "choiceId": "alibaba-model-studio-api-key",
+      "choiceLabel": "Alibaba Model Studio API key",
+      "groupId": "alibaba",
+      "groupLabel": "Alibaba Model Studio",
+      "groupHint": "DashScope / Model Studio API key",
+      "onboardingScopes": ["image-generation"],
+      "optionKey": "alibabaModelStudioApiKey",
+      "cliFlag": "--alibaba-model-studio-api-key",
+      "cliOption": "--alibaba-model-studio-api-key <key>",
+      "cliDescription": "Alibaba Model Studio API key"
+    }
+  ],
+  "contracts": {
+    "videoGenerationProviders": ["alibaba"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

extensions/alibaba/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@openclaw/alibaba-provider",
+  "version": "2026.6.11",
+  "private": true,
+  "description": "OpenClaw Alibaba Model Studio video provider plugin",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

extensions/alibaba/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}

extensions/alibaba/video-generation-provider.test.ts

@@ -0,0 +1,93 @@
+// Alibaba tests cover video generation provider plugin behavior.
+import {
+  getProviderHttpMocks,
+  installProviderHttpMockCleanup,
+} from "openclaw/plugin-sdk/provider-http-test-mocks";
+import {
+  expectDashscopeVideoTaskPoll,
+  expectExplicitVideoGenerationCapabilities,
+  expectSuccessfulDashscopeVideoResult,
+  mockSuccessfulDashscopeVideoTask,
+} from "openclaw/plugin-sdk/provider-test-contracts";
+import { beforeAll, describe, expect, it } from "vitest";
+
+const { postJsonRequestMock, fetchWithTimeoutMock } = getProviderHttpMocks();
+
+let buildAlibabaVideoGenerationProvider: typeof import("./video-generation-provider.js").buildAlibabaVideoGenerationProvider;
+
+beforeAll(async () => {
+  ({ buildAlibabaVideoGenerationProvider } = await import("./video-generation-provider.js"));
+});
+
+installProviderHttpMockCleanup();
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`expected ${label} to be a record`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireFirstPostJsonRequest(label: string): Record<string, unknown> {
+  const [call] = postJsonRequestMock.mock.calls;
+  if (!call) {
+    throw new Error(`expected ${label}`);
+  }
+  return requireRecord(call[0], label);
+}
+
+describe("alibaba video generation provider", () => {
+  it("declares explicit mode capabilities", () => {
+    expectExplicitVideoGenerationCapabilities(buildAlibabaVideoGenerationProvider());
+  });
+
+  it("submits async Wan generation, polls task status, and downloads the resulting video", async () => {
+    mockSuccessfulDashscopeVideoTask({ postJsonRequestMock, fetchWithTimeoutMock });
+
+    const provider = buildAlibabaVideoGenerationProvider();
+    const result = await provider.generateVideo({
+      provider: "alibaba",
+      model: "wan2.6-r2v-flash",
+      prompt: "animate this shot",
+      cfg: {},
+      inputImages: [{ url: "https://example.com/ref.png" }],
+      durationSeconds: 6,
+      audio: true,
+      watermark: false,
+    });
+
+    expect(postJsonRequestMock).toHaveBeenCalledOnce();
+    const request = requireFirstPostJsonRequest("DashScope request");
+    expect(request.url).toBe(
+      "https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/video-generation/video-synthesis",
+    );
+    const body = requireRecord(request.body, "DashScope request body");
+    expect(body.model).toBe("wan2.6-r2v-flash");
+    const input = requireRecord(body.input, "DashScope request input");
+    expect(input.prompt).toBe("animate this shot");
+    expect(input.img_url).toBe("https://example.com/ref.png");
+    const parameters = requireRecord(body.parameters, "DashScope request parameters");
+    expect(parameters.duration).toBe(6);
+    expect(parameters.enable_audio).toBe(true);
+    expect(parameters.watermark).toBe(false);
+    expectDashscopeVideoTaskPoll(fetchWithTimeoutMock);
+    expectSuccessfulDashscopeVideoResult(result);
+  });
+
+  it("fails fast when reference inputs are local buffers instead of remote URLs", async () => {
+    const provider = buildAlibabaVideoGenerationProvider();
+
+    await expect(
+      provider.generateVideo({
+        provider: "alibaba",
+        model: "wan2.6-i2v",
+        prompt: "animate this local frame",
+        cfg: {},
+        inputImages: [{ buffer: Buffer.from("png-bytes"), mimeType: "image/png" }],
+      }),
+    ).rejects.toThrow(
+      "Alibaba Wan video generation currently requires remote http(s) URLs for reference images/videos.",
+    );
+    expect(postJsonRequestMock).not.toHaveBeenCalled();
+  });
+});

extensions/alibaba/video-generation-provider.ts

@@ -0,0 +1,88 @@
+/**
+ * Alibaba Model Studio video provider adapter. It resolves DashScope auth and
+ * HTTP policy before delegating task polling to the shared video helper.
+ */
+import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+import { resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+import {
+  DASHSCOPE_WAN_VIDEO_CAPABILITIES,
+  DASHSCOPE_WAN_VIDEO_MODELS,
+  DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL,
+  DEFAULT_VIDEO_GENERATION_TIMEOUT_MS,
+  runDashscopeVideoGenerationTask,
+} from "openclaw/plugin-sdk/video-generation";
+import type {
+  VideoGenerationProvider,
+  VideoGenerationRequest,
+  VideoGenerationResult,
+} from "openclaw/plugin-sdk/video-generation";
+
+const DEFAULT_ALIBABA_VIDEO_BASE_URL = "https://dashscope-intl.aliyuncs.com";
+const DEFAULT_ALIBABA_VIDEO_MODEL = DEFAULT_DASHSCOPE_WAN_VIDEO_MODEL;
+
+function resolveAlibabaVideoBaseUrl(req: VideoGenerationRequest): string {
+  return req.cfg?.models?.providers?.alibaba?.baseUrl?.trim() || DEFAULT_ALIBABA_VIDEO_BASE_URL;
+}
+
+function resolveDashscopeAigcApiBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/u, "");
+}
+
+/** Build the Alibaba/DashScope video generation provider descriptor. */
+export function buildAlibabaVideoGenerationProvider(): VideoGenerationProvider {
+  return {
+    id: "alibaba",
+    label: "Alibaba Model Studio",
+    defaultModel: DEFAULT_ALIBABA_VIDEO_MODEL,
+    models: [...DASHSCOPE_WAN_VIDEO_MODELS],
+    isConfigured: ({ agentDir }) =>
+      isProviderApiKeyConfigured({
+        provider: "alibaba",
+        agentDir,
+      }),
+    capabilities: DASHSCOPE_WAN_VIDEO_CAPABILITIES,
+    async generateVideo(req): Promise<VideoGenerationResult> {
+      const fetchFn = fetch;
+      const auth = await resolveApiKeyForProvider({
+        provider: "alibaba",
+        cfg: req.cfg,
+        agentDir: req.agentDir,
+        store: req.authStore,
+      });
+      if (!auth.apiKey) {
+        throw new Error("Alibaba Model Studio API key missing");
+      }
+
+      const requestBaseUrl = resolveAlibabaVideoBaseUrl(req);
+      const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } =
+        resolveProviderHttpRequestConfig({
+          baseUrl: requestBaseUrl,
+          defaultBaseUrl: DEFAULT_ALIBABA_VIDEO_BASE_URL,
+          defaultHeaders: {
+            Authorization: `Bearer ${auth.apiKey}`,
+            "Content-Type": "application/json",
+            "X-DashScope-Async": "enable",
+          },
+          provider: "alibaba",
+          capability: "video",
+          transport: "http",
+        });
+
+      const model = req.model?.trim() || DEFAULT_ALIBABA_VIDEO_MODEL;
+      return await runDashscopeVideoGenerationTask({
+        providerLabel: "Alibaba Wan",
+        model,
+        req,
+        url: `${resolveDashscopeAigcApiBaseUrl(baseUrl)}/api/v1/services/aigc/video-generation/video-synthesis`,
+        headers,
+        baseUrl: resolveDashscopeAigcApiBaseUrl(baseUrl),
+        timeoutMs: req.timeoutMs,
+        fetchFn,
+        allowPrivateNetwork,
+        dispatcherPolicy,
+        defaultTimeoutMs: DEFAULT_VIDEO_GENERATION_TIMEOUT_MS,
+      });
+    },
+  };
+}