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

@@ -0,0 +1,479 @@
+// Minimax tests cover index plugin behavior.
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { StreamFn } from "openclaw/plugin-sdk/agent-core";
+import type { Context, Model } from "openclaw/plugin-sdk/llm";
+import {
+  registerProviderPlugin,
+  requireRegisteredProvider,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { registerMinimaxProviders } from "./provider-registration.js";
+import { createMiniMaxWebSearchProvider } from "./src/minimax-web-search-provider.js";
+
+vi.mock("./oauth.runtime.js", () => ({
+  loginMiniMaxPortalOAuth: vi.fn(async () => ({
+    access: "minimax-oauth-access-token",
+    refresh: "minimax-oauth-refresh-token",
+    expires: Date.now() + 60_000,
+    resourceUrl: "https://api.minimax.io/anthropic",
+  })),
+}));
+
+const minimaxProviderPlugin = {
+  register(api: Parameters<typeof registerMinimaxProviders>[0]) {
+    registerMinimaxProviders(api);
+    api.registerWebSearchProvider(createMiniMaxWebSearchProvider());
+  },
+};
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+describe("minimax provider hooks", () => {
+  it("declares CN provider auth aliases in the manifest", () => {
+    const pluginJson = JSON.parse(
+      readFileSync(resolve(import.meta.dirname, "openclaw.plugin.json"), "utf-8"),
+    );
+
+    expect(pluginJson.providerAuthAliases).toEqual({
+      "minimax-cn": "minimax",
+      "minimax-portal-cn": "minimax-portal",
+    });
+  });
+
+  it("keeps native reasoning mode for MiniMax transports", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    expect(apiProvider.hookAliases).toContain("minimax-cn");
+    expect(
+      apiProvider.resolveReasoningOutputMode?.({
+        provider: "minimax",
+        modelApi: "anthropic-messages",
+        modelId: "MiniMax-M2.7",
+      } as never),
+    ).toBe("native");
+
+    expect(portalProvider.hookAliases).toContain("minimax-portal-cn");
+    expect(
+      portalProvider.resolveReasoningOutputMode?.({
+        provider: "minimax-portal",
+        modelApi: "anthropic-messages",
+        modelId: "MiniMax-M2.7",
+      } as never),
+    ).toBe("native");
+  });
+
+  it("defaults M3 thinking on while keeping M2.x thinking off by default", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    expect(apiProvider.resolveThinkingProfile?.({ modelId: "MiniMax-M3" } as never)).toMatchObject({
+      defaultLevel: "adaptive",
+    });
+    expect(
+      apiProvider.resolveThinkingProfile?.({ modelId: "MiniMax-M2.7" } as never),
+    ).toMatchObject({
+      defaultLevel: "off",
+    });
+    expect(
+      portalProvider.resolveThinkingProfile?.({ modelId: "MiniMax-M3" } as never),
+    ).toMatchObject({
+      defaultLevel: "adaptive",
+    });
+  });
+
+  it("keeps MiniMax auth setup metadata aligned across regions", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    expect(
+      apiProvider.auth.map((method) => ({
+        id: method.id,
+        label: method.label,
+        hint: method.hint,
+        choiceId: method.wizard?.choiceId,
+        groupId: method.wizard?.groupId,
+        groupHint: method.wizard?.groupHint,
+      })),
+    ).toEqual([
+      {
+        id: "api-global",
+        label: "MiniMax API key (Global)",
+        hint: "Global endpoint - api.minimax.io",
+        choiceId: "minimax-global-api",
+        groupId: "minimax",
+        groupHint: "M3 (recommended)",
+      },
+      {
+        id: "api-cn",
+        label: "MiniMax API key (CN)",
+        hint: "CN endpoint - api.minimaxi.com",
+        choiceId: "minimax-cn-api",
+        groupId: "minimax",
+        groupHint: "M3 (recommended)",
+      },
+    ]);
+
+    expect(
+      portalProvider.auth.map((method) => ({
+        id: method.id,
+        label: method.label,
+        hint: method.hint,
+        choiceId: method.wizard?.choiceId,
+        groupId: method.wizard?.groupId,
+        groupHint: method.wizard?.groupHint,
+      })),
+    ).toEqual([
+      {
+        id: "oauth",
+        label: "MiniMax OAuth (Global)",
+        hint: "Global endpoint - api.minimax.io",
+        choiceId: "minimax-global-oauth",
+        groupId: "minimax",
+        groupHint: "M3 (recommended)",
+      },
+      {
+        id: "oauth-cn",
+        label: "MiniMax OAuth (CN)",
+        hint: "CN endpoint - api.minimaxi.com",
+        choiceId: "minimax-cn-oauth",
+        groupId: "minimax",
+        groupHint: "M3 (recommended)",
+      },
+    ]);
+  });
+
+  it("owns replay policy for Anthropic and OpenAI-compatible MiniMax transports", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    expect(
+      apiProvider.buildReplayPolicy?.({
+        provider: "minimax",
+        modelApi: "anthropic-messages",
+        modelId: "MiniMax-M2.7",
+      } as never),
+    ).toEqual({
+      sanitizeMode: "full",
+      sanitizeToolCallIds: true,
+      toolCallIdMode: "strict",
+      preserveSignatures: true,
+      repairToolUseResultPairing: true,
+      validateAnthropicTurns: true,
+      allowSyntheticToolResults: true,
+    });
+
+    expect(
+      portalProvider.buildReplayPolicy?.({
+        provider: "minimax-portal",
+        modelApi: "openai-completions",
+        modelId: "MiniMax-M2.7",
+      } as never),
+    ).toEqual({
+      sanitizeToolCallIds: true,
+      toolCallIdMode: "strict",
+      applyAssistantFirstOrderingFix: true,
+      validateGeminiTurns: true,
+      validateAnthropicTurns: true,
+      dropReasoningFromHistory: true,
+    });
+  });
+
+  it("lists M3 on the Anthropic Messages route used by the empty-history guard", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+
+    const catalog = await apiProvider.catalog?.run({
+      env: {},
+      config: {},
+      resolveProviderApiKey: (providerId?: string) => ({
+        apiKey: providerId === "minimax" ? "sk-minimax-test" : undefined,
+      }),
+    } as never);
+
+    const provider = catalog && "provider" in catalog ? catalog.provider : undefined;
+    expect(provider?.api).toBe("anthropic-messages");
+    expect(provider?.authHeader).toBe(true);
+    expect(provider?.baseUrl).toBe("https://api.minimax.io/anthropic");
+    const model = provider?.models.find((entry: { id?: string }) => entry.id === "MiniMax-M3");
+    expect(model?.id).toBe("MiniMax-M3");
+    expect(model?.input).toEqual(["text", "image"]);
+    expect(model?.name).toBe("MiniMax M3");
+    expect(model?.reasoning).toBe(true);
+  });
+
+  it("resolves M3 through the dynamic model hook before agent discovery", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+
+    const model = apiProvider.resolveDynamicModel?.({
+      provider: "minimax",
+      modelId: "MiniMax-M3",
+      providerConfig: {},
+    } as never);
+
+    expect(model).toMatchObject({
+      provider: "minimax",
+      id: "MiniMax-M3",
+      api: "anthropic-messages",
+      baseUrl: "https://api.minimax.io/anthropic",
+      input: ["text", "image"],
+      contextWindow: 1_000_000,
+    });
+  });
+
+  it("keeps MINIMAX_API_HOST endpoint overrides on dynamic M3 resolution", async () => {
+    vi.stubEnv("MINIMAX_API_HOST", "https://api.minimaxi.com");
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+
+    const model = apiProvider.resolveDynamicModel?.({
+      provider: "minimax",
+      modelId: "MiniMax-M3",
+      providerConfig: {},
+    } as never);
+
+    expect(model?.baseUrl).toBe("https://api.minimaxi.com/anthropic");
+  });
+
+  it("owns fast-mode stream wrapping for MiniMax transports", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    let resolvedApiModelId = "";
+    const captureApiModel: StreamFn = (model) => {
+      resolvedApiModelId = model.id ?? "";
+      return {} as ReturnType<StreamFn>;
+    };
+    const wrappedApiStream = apiProvider.wrapStreamFn?.({
+      provider: "minimax",
+      modelId: "MiniMax-M2.7",
+      extraParams: { fastMode: true },
+      streamFn: captureApiModel,
+    } as never);
+
+    void wrappedApiStream?.(
+      {
+        api: "anthropic-messages",
+        provider: "minimax",
+        id: "MiniMax-M2.7",
+      } as Model<"anthropic-messages">,
+      { messages: [] } as Context,
+      {},
+    );
+
+    let resolvedPortalModelId = "";
+    const capturePortalModel: StreamFn = (model) => {
+      resolvedPortalModelId = model.id ?? "";
+      return {} as ReturnType<StreamFn>;
+    };
+    const wrappedPortalStream = portalProvider.wrapStreamFn?.({
+      provider: "minimax-portal",
+      modelId: "MiniMax-M2.7",
+      extraParams: { fastMode: true },
+      streamFn: capturePortalModel,
+    } as never);
+
+    void wrappedPortalStream?.(
+      {
+        api: "anthropic-messages",
+        provider: "minimax-portal",
+        id: "MiniMax-M2.7",
+      } as Model<"anthropic-messages">,
+      { messages: [] } as Context,
+      {},
+    );
+
+    expect(resolvedApiModelId).toBe("MiniMax-M2.7-highspeed");
+    expect(resolvedPortalModelId).toBe("MiniMax-M2.7-highspeed");
+  });
+
+  it("shares the provider hook bundle across MiniMax variants", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+
+    expect(apiProvider.buildReplayPolicy).toBe(portalProvider.buildReplayPolicy);
+    expect(apiProvider.wrapStreamFn).toBe(portalProvider.wrapStreamFn);
+    expect(apiProvider.resolveReasoningOutputMode).toBe(portalProvider.resolveReasoningOutputMode);
+  });
+
+  it("registers the bundled MiniMax web search provider", () => {
+    const webSearchProviders: unknown[] = [];
+
+    minimaxProviderPlugin.register({
+      registerProvider() {},
+      registerMediaUnderstandingProvider() {},
+      registerImageGenerationProvider() {},
+      registerMusicGenerationProvider() {},
+      registerVideoGenerationProvider() {},
+      registerSpeechProvider() {},
+      registerWebSearchProvider(provider: unknown) {
+        webSearchProviders.push(provider);
+      },
+    } as never);
+
+    expect(webSearchProviders).toHaveLength(1);
+    const provider = webSearchProviders[0] as
+      | {
+          id?: unknown;
+          label?: unknown;
+          onboardingScopes?: unknown;
+          envVars?: unknown;
+        }
+      | undefined;
+    expect(provider?.id).toBe("minimax");
+    expect(provider?.label).toBe("MiniMax Search");
+    expect(provider?.onboardingScopes).toEqual(["text-inference"]);
+    expect(provider?.envVars).toEqual([
+      "MINIMAX_CODE_PLAN_KEY",
+      "MINIMAX_CODING_API_KEY",
+      "MINIMAX_OAUTH_TOKEN",
+      "MINIMAX_API_KEY",
+    ]);
+  });
+
+  it("prefers minimax-portal oauth when resolving MiniMax usage auth", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const resolveOAuthToken = vi.fn(async (params?: { provider?: string }) =>
+      params?.provider === "minimax-portal" ? { token: "portal-oauth-token" } : null,
+    );
+    const resolveApiKeyFromConfigAndStore = vi.fn(() => undefined);
+
+    await expect(
+      apiProvider.resolveUsageAuth?.({
+        provider: "minimax",
+        config: {},
+        env: {},
+        resolveOAuthToken,
+        resolveApiKeyFromConfigAndStore,
+      } as never),
+    ).resolves.toEqual({ token: "portal-oauth-token" });
+
+    expect(resolveOAuthToken).toHaveBeenCalledWith({ provider: "minimax-portal" });
+    expect(resolveApiKeyFromConfigAndStore).not.toHaveBeenCalled();
+  });
+
+  it("uses the configured MiniMax base URL for usage snapshots", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const apiProvider = requireRegisteredProvider(providers, "minimax");
+    const fetchFn = vi.fn(async (input: string | URL | Request) => {
+      const url =
+        typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+      expect(url).toBe("https://api.minimax.io/v1/token_plan/remains");
+      return new Response(
+        JSON.stringify({
+          data: {
+            current_interval_total_count: 100,
+            current_interval_usage_count: 98,
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    });
+
+    const result = await apiProvider.fetchUsageSnapshot?.({
+      provider: "minimax",
+      config: {
+        models: {
+          providers: {
+            minimax: {
+              baseUrl: "https://api.minimax.io/anthropic",
+              models: [],
+            },
+          },
+        },
+      },
+      env: {},
+      token: "key",
+      timeoutMs: 5000,
+      fetchFn: fetchFn as typeof fetch,
+    } as never);
+
+    expect(result?.windows).toEqual([{ label: "5h", usedPercent: 2, resetAt: undefined }]);
+  });
+
+  it("writes api and authHeader into the MiniMax portal OAuth config patch", async () => {
+    const { providers } = await registerProviderPlugin({
+      plugin: minimaxProviderPlugin,
+      id: "minimax",
+      name: "MiniMax Provider",
+    });
+    const portalProvider = requireRegisteredProvider(providers, "minimax-portal");
+    const oauthMethod = portalProvider.auth.find((method) => method.id === "oauth");
+
+    if (!oauthMethod) {
+      throw new Error("expected minimax portal oauth auth method");
+    }
+
+    const result = await oauthMethod.run({
+      prompter: {
+        progress() {
+          return { stop() {} };
+        },
+        note: vi.fn(async () => undefined),
+      },
+      openUrl: vi.fn(async () => undefined),
+    } as never);
+
+    expect(result?.configPatch?.models?.providers?.["minimax-portal"]).toEqual({
+      baseUrl: "https://api.minimax.io/anthropic",
+      api: "anthropic-messages",
+      authHeader: true,
+      models: [],
+    });
+  });
+});