重构主控编排与运行时预热链路，统一工作区提示词/专家调度协议并补齐 wiki 记忆注入与写回闭环。

同时收敛启动与运维脚本默认行为（含 wiki worker）、更新 Admin 可观测性与相关测试，降低首轮时延并提高运行稳定性。

Made-with: Cursor

openclaw/test/helpers/media-generation/bundled-provider-builders.ts

@@ -0,0 +1,15 @@
+import type { OpenClawPluginApi } from "../../../src/plugins/types.js";
+import { loadBundledPluginPublicSurfaceSync } from "../../../src/test-utils/bundled-plugin-public-surface.js";
+
+type BundledPluginEntryModule = {
+  default: {
+    register(api: OpenClawPluginApi): void;
+  };
+};
+
+export function loadBundledProviderPlugin(pluginId: string): BundledPluginEntryModule["default"] {
+  return loadBundledPluginPublicSurfaceSync<BundledPluginEntryModule>({
+    pluginId,
+    artifactBasename: "index.js",
+  }).default;
+}

openclaw/test/helpers/media-generation/dashscope-video-provider.ts

@@ -0,0 +1,118 @@
+import type { VideoGenerationResult } from "openclaw/plugin-sdk/video-generation";
+import { expect, vi } from "vitest";
+
+type ClearableMock = {
+  mockClear(): unknown;
+};
+
+type ResettableMock = {
+  mockReset(): unknown;
+};
+
+type ResolvableMock = {
+  mockResolvedValue(value: unknown): unknown;
+};
+
+type ChainableResolvedValueMock = ResettableMock & {
+  mockResolvedValueOnce(value: unknown): ChainableResolvedValueMock;
+};
+
+export type DashscopeVideoProviderMocks = {
+  resolveApiKeyForProviderMock: ClearableMock;
+  postJsonRequestMock: ResettableMock & ResolvableMock;
+  fetchWithTimeoutMock: ChainableResolvedValueMock;
+  assertOkOrThrowHttpErrorMock: ClearableMock;
+  resolveProviderHttpRequestConfigMock: ClearableMock;
+};
+
+export function resetDashscopeVideoProviderMocks(mocks: DashscopeVideoProviderMocks): void {
+  mocks.resolveApiKeyForProviderMock.mockClear();
+  mocks.postJsonRequestMock.mockReset();
+  mocks.fetchWithTimeoutMock.mockReset();
+  mocks.assertOkOrThrowHttpErrorMock.mockClear();
+  mocks.resolveProviderHttpRequestConfigMock.mockClear();
+}
+
+export function mockSuccessfulDashscopeVideoTask(
+  mocks: Pick<DashscopeVideoProviderMocks, "postJsonRequestMock" | "fetchWithTimeoutMock">,
+  params: {
+    requestId?: string;
+    taskId?: string;
+    taskStatus?: string;
+    videoUrl?: string;
+  } = {},
+): void {
+  const {
+    requestId = "req-1",
+    taskId = "task-1",
+    taskStatus = "SUCCEEDED",
+    videoUrl = "https://example.com/out.mp4",
+  } = params;
+  mocks.postJsonRequestMock.mockResolvedValue({
+    response: {
+      json: async () => ({
+        request_id: requestId,
+        output: {
+          task_id: taskId,
+        },
+      }),
+    },
+    release: vi.fn(async () => {}),
+  });
+  mocks.fetchWithTimeoutMock
+    .mockResolvedValueOnce({
+      json: async () => ({
+        output: {
+          task_status: taskStatus,
+          results: [{ video_url: videoUrl }],
+        },
+      }),
+      headers: new Headers(),
+    })
+    .mockResolvedValueOnce({
+      arrayBuffer: async () => Buffer.from("mp4-bytes"),
+      headers: new Headers({ "content-type": "video/mp4" }),
+    });
+}
+
+export function expectDashscopeVideoTaskPoll(
+  fetchWithTimeoutMock: ChainableResolvedValueMock,
+  params: {
+    baseUrl?: string;
+    taskId?: string;
+    timeoutMs?: number;
+  } = {},
+): void {
+  const {
+    baseUrl = "https://dashscope-intl.aliyuncs.com",
+    taskId = "task-1",
+    timeoutMs = 120_000,
+  } = params;
+  expect(fetchWithTimeoutMock).toHaveBeenNthCalledWith(
+    1,
+    `${baseUrl}/api/v1/tasks/${taskId}`,
+    expect.objectContaining({ method: "GET" }),
+    timeoutMs,
+    fetch,
+  );
+}
+
+export function expectSuccessfulDashscopeVideoResult(
+  result: VideoGenerationResult,
+  params: {
+    requestId?: string;
+    taskId?: string;
+    taskStatus?: string;
+  } = {},
+): void {
+  const { requestId = "req-1", taskId = "task-1", taskStatus = "SUCCEEDED" } = params;
+  expect(result.videos).toHaveLength(1);
+  expect(result.videos[0]?.mimeType).toBe("video/mp4");
+  expect(result.metadata).toEqual(
+    expect.objectContaining({
+      requestId,
+      taskId,
+      taskStatus,
+    }),
+  );
+}

openclaw/test/helpers/media-generation/provider-capability-assertions.ts

@@ -0,0 +1,68 @@
+import { expect } from "vitest";
+import { listSupportedMusicGenerationModes } from "../../../src/music-generation/capabilities.js";
+import type {
+  MusicGenerationProviderPlugin,
+  VideoGenerationProviderPlugin,
+} from "../../../src/plugins/types.js";
+import { listSupportedVideoGenerationModes } from "../../../src/video-generation/capabilities.js";
+
+export function expectExplicitVideoGenerationCapabilities(
+  provider: VideoGenerationProviderPlugin,
+): void {
+  expect(
+    provider.capabilities.generate,
+    `${provider.id} missing generate capabilities`,
+  ).toBeDefined();
+  expect(
+    provider.capabilities.imageToVideo,
+    `${provider.id} missing imageToVideo capabilities`,
+  ).toBeDefined();
+  expect(
+    provider.capabilities.videoToVideo,
+    `${provider.id} missing videoToVideo capabilities`,
+  ).toBeDefined();
+
+  const supportedModes = listSupportedVideoGenerationModes(provider);
+  const imageToVideo = provider.capabilities.imageToVideo;
+  const videoToVideo = provider.capabilities.videoToVideo;
+
+  if (imageToVideo?.enabled) {
+    expect(
+      imageToVideo.maxInputImages ?? 0,
+      `${provider.id} imageToVideo.enabled requires maxInputImages`,
+    ).toBeGreaterThan(0);
+    expect(supportedModes).toContain("imageToVideo");
+  }
+  if (videoToVideo?.enabled) {
+    expect(
+      videoToVideo.maxInputVideos ?? 0,
+      `${provider.id} videoToVideo.enabled requires maxInputVideos`,
+    ).toBeGreaterThan(0);
+    expect(supportedModes).toContain("videoToVideo");
+  }
+}
+
+export function expectExplicitMusicGenerationCapabilities(
+  provider: MusicGenerationProviderPlugin,
+): void {
+  expect(
+    provider.capabilities.generate,
+    `${provider.id} missing generate capabilities`,
+  ).toBeDefined();
+  expect(provider.capabilities.edit, `${provider.id} missing edit capabilities`).toBeDefined();
+
+  const edit = provider.capabilities.edit;
+  if (!edit) {
+    return;
+  }
+
+  if (edit.enabled) {
+    expect(
+      edit.maxInputImages ?? 0,
+      `${provider.id} edit.enabled requires maxInputImages`,
+    ).toBeGreaterThan(0);
+    expect(listSupportedMusicGenerationModes(provider)).toContain("edit");
+  } else {
+    expect(listSupportedMusicGenerationModes(provider)).toEqual(["generate"]);
+  }
+}

openclaw/test/helpers/media-generation/provider-http-mocks.ts

@@ -0,0 +1,57 @@
+import type { resolveProviderHttpRequestConfig } from "openclaw/plugin-sdk/provider-http";
+import { afterEach, vi } from "vitest";
+
+type ResolveProviderHttpRequestConfigParams = Parameters<
+  typeof resolveProviderHttpRequestConfig
+>[0];
+
+const providerHttpMocks = vi.hoisted(() => ({
+  resolveApiKeyForProviderMock: vi.fn(async () => ({ apiKey: "provider-key" })),
+  postJsonRequestMock: vi.fn(),
+  fetchWithTimeoutMock: vi.fn(),
+  assertOkOrThrowHttpErrorMock: vi.fn(async () => {}),
+  resolveProviderHttpRequestConfigMock: vi.fn((params: ResolveProviderHttpRequestConfigParams) => ({
+    baseUrl: params.baseUrl ?? params.defaultBaseUrl,
+    allowPrivateNetwork: false,
+    headers: new Headers(params.defaultHeaders),
+    dispatcherPolicy: undefined,
+  })),
+}));
+
+vi.mock("openclaw/plugin-sdk/provider-auth-runtime", () => ({
+  resolveApiKeyForProvider: providerHttpMocks.resolveApiKeyForProviderMock,
+}));
+
+vi.mock("openclaw/plugin-sdk/provider-http", () => ({
+  assertOkOrThrowHttpError: providerHttpMocks.assertOkOrThrowHttpErrorMock,
+  createProviderOperationDeadline: ({
+    label,
+    timeoutMs,
+  }: {
+    label: string;
+    timeoutMs?: number;
+  }) => ({
+    label,
+    timeoutMs,
+  }),
+  fetchWithTimeout: providerHttpMocks.fetchWithTimeoutMock,
+  postJsonRequest: providerHttpMocks.postJsonRequestMock,
+  resolveProviderOperationTimeoutMs: ({ defaultTimeoutMs }: { defaultTimeoutMs: number }) =>
+    defaultTimeoutMs,
+  resolveProviderHttpRequestConfig: providerHttpMocks.resolveProviderHttpRequestConfigMock,
+  waitProviderOperationPollInterval: async () => {},
+}));
+
+export function getProviderHttpMocks() {
+  return providerHttpMocks;
+}
+
+export function installProviderHttpMockCleanup(): void {
+  afterEach(() => {
+    providerHttpMocks.resolveApiKeyForProviderMock.mockClear();
+    providerHttpMocks.postJsonRequestMock.mockReset();
+    providerHttpMocks.fetchWithTimeoutMock.mockReset();
+    providerHttpMocks.assertOkOrThrowHttpErrorMock.mockClear();
+    providerHttpMocks.resolveProviderHttpRequestConfigMock.mockClear();
+  });
+}

openclaw/test/helpers/media-generation/runtime-module-mocks.ts

@@ -0,0 +1,156 @@
+import { vi } from "vitest";
+import type { OpenClawConfig } from "../../../src/config/config.js";
+import type { ImageGenerationProvider } from "../../../src/image-generation/types.js";
+import type { MusicGenerationProvider } from "../../../src/music-generation/types.js";
+import type { VideoGenerationProvider } from "../../../src/video-generation/types.js";
+import { resetGenerationRuntimeMocks } from "./runtime-test-mocks.js";
+
+type ModelRef = { provider: string; model: string };
+
+const mediaRuntimeMocks = vi.hoisted(() => {
+  const debug = vi.fn();
+  const warn = vi.fn();
+  const parseGenerationModelRef = (raw?: string): ModelRef | undefined => {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+      return undefined;
+    }
+    const slash = trimmed.indexOf("/");
+    if (slash <= 0 || slash === trimmed.length - 1) {
+      return undefined;
+    }
+    return {
+      provider: trimmed.slice(0, slash),
+      model: trimmed.slice(slash + 1),
+    };
+  };
+  return {
+    createSubsystemLogger: vi.fn(() => ({ debug, warn: vi.fn() })),
+    describeFailoverError: vi.fn(),
+    getImageGenerationProvider: vi.fn<
+      (providerId: string, config?: OpenClawConfig) => ImageGenerationProvider | undefined
+    >(() => undefined),
+    getMusicGenerationProvider: vi.fn<
+      (providerId: string, config?: OpenClawConfig) => MusicGenerationProvider | undefined
+    >(() => undefined),
+    getProviderEnvVars: vi.fn<(providerId: string) => string[]>(() => []),
+    getVideoGenerationProvider: vi.fn<
+      (providerId: string, config?: OpenClawConfig) => VideoGenerationProvider | undefined
+    >(() => undefined),
+    isFailoverError: vi.fn<(err: unknown) => boolean>(() => false),
+    listImageGenerationProviders: vi.fn<(config?: OpenClawConfig) => ImageGenerationProvider[]>(
+      () => [],
+    ),
+    listMusicGenerationProviders: vi.fn<(config?: OpenClawConfig) => MusicGenerationProvider[]>(
+      () => [],
+    ),
+    listVideoGenerationProviders: vi.fn<(config?: OpenClawConfig) => VideoGenerationProvider[]>(
+      () => [],
+    ),
+    parseImageGenerationModelRef:
+      vi.fn<(raw?: string) => ModelRef | undefined>(parseGenerationModelRef),
+    parseMusicGenerationModelRef:
+      vi.fn<(raw?: string) => ModelRef | undefined>(parseGenerationModelRef),
+    parseVideoGenerationModelRef:
+      vi.fn<(raw?: string) => ModelRef | undefined>(parseGenerationModelRef),
+    ensureAuthProfileStore: vi.fn(() => ({ version: 1, profiles: {} })),
+    listProfilesForProvider: vi.fn(() => []),
+    resolveEnvApiKey: vi.fn(() => undefined),
+    resolveAgentModelFallbackValues: vi.fn<(value: unknown) => string[]>(() => []),
+    resolveAgentModelPrimaryValue: vi.fn<(value: unknown) => string | undefined>(() => undefined),
+    resolveProviderAuthEnvVarCandidates: vi.fn(() => ({})),
+    debug,
+    warn,
+  };
+});
+
+vi.mock("../../../src/agents/auth-profiles.js", () => ({
+  ensureAuthProfileStore: mediaRuntimeMocks.ensureAuthProfileStore,
+  listProfilesForProvider: mediaRuntimeMocks.listProfilesForProvider,
+}));
+vi.mock("../../../src/agents/defaults.js", () => ({
+  DEFAULT_PROVIDER: "openai",
+}));
+vi.mock("../../../src/agents/failover-error.js", () => ({
+  describeFailoverError: mediaRuntimeMocks.describeFailoverError,
+  isFailoverError: mediaRuntimeMocks.isFailoverError,
+}));
+vi.mock("../../../src/agents/model-auth-env.js", () => ({
+  resolveEnvApiKey: mediaRuntimeMocks.resolveEnvApiKey,
+}));
+vi.mock("../../../src/config/model-input.js", () => ({
+  resolveAgentModelFallbackValues: mediaRuntimeMocks.resolveAgentModelFallbackValues,
+  resolveAgentModelPrimaryValue: mediaRuntimeMocks.resolveAgentModelPrimaryValue,
+}));
+vi.mock("../../../src/logging/subsystem.js", () => ({
+  createSubsystemLogger: mediaRuntimeMocks.createSubsystemLogger,
+}));
+vi.mock("../../../src/secrets/provider-env-vars.js", () => ({
+  getProviderEnvVars: mediaRuntimeMocks.getProviderEnvVars,
+  resolveProviderAuthEnvVarCandidates: mediaRuntimeMocks.resolveProviderAuthEnvVarCandidates,
+}));
+
+vi.mock("../../../src/image-generation/model-ref.js", () => ({
+  parseImageGenerationModelRef: mediaRuntimeMocks.parseImageGenerationModelRef,
+}));
+vi.mock("../../../src/image-generation/provider-registry.js", () => ({
+  getImageGenerationProvider: mediaRuntimeMocks.getImageGenerationProvider,
+  listImageGenerationProviders: mediaRuntimeMocks.listImageGenerationProviders,
+}));
+vi.mock("../../../src/music-generation/model-ref.js", () => ({
+  parseMusicGenerationModelRef: mediaRuntimeMocks.parseMusicGenerationModelRef,
+}));
+vi.mock("../../../src/music-generation/provider-registry.js", () => ({
+  getMusicGenerationProvider: mediaRuntimeMocks.getMusicGenerationProvider,
+  listMusicGenerationProviders: mediaRuntimeMocks.listMusicGenerationProviders,
+}));
+vi.mock("../../../src/video-generation/model-ref.js", () => ({
+  parseVideoGenerationModelRef: mediaRuntimeMocks.parseVideoGenerationModelRef,
+}));
+vi.mock("../../../src/video-generation/provider-registry.js", () => ({
+  getVideoGenerationProvider: mediaRuntimeMocks.getVideoGenerationProvider,
+  listVideoGenerationProviders: mediaRuntimeMocks.listVideoGenerationProviders,
+}));
+
+export function getMediaGenerationRuntimeMocks() {
+  return mediaRuntimeMocks;
+}
+
+export function resetImageGenerationRuntimeMocks(): void {
+  resetSharedRuntimeImportMocks();
+  resetGenerationRuntimeMocks({
+    ...mediaRuntimeMocks,
+    getProvider: mediaRuntimeMocks.getImageGenerationProvider,
+    listProviders: mediaRuntimeMocks.listImageGenerationProviders,
+    parseModelRef: mediaRuntimeMocks.parseImageGenerationModelRef,
+  });
+}
+
+export function resetMusicGenerationRuntimeMocks(): void {
+  resetSharedRuntimeImportMocks();
+  resetGenerationRuntimeMocks({
+    ...mediaRuntimeMocks,
+    getProvider: mediaRuntimeMocks.getMusicGenerationProvider,
+    listProviders: mediaRuntimeMocks.listMusicGenerationProviders,
+    parseModelRef: mediaRuntimeMocks.parseMusicGenerationModelRef,
+  });
+}
+
+export function resetVideoGenerationRuntimeMocks(): void {
+  resetSharedRuntimeImportMocks();
+  resetGenerationRuntimeMocks({
+    ...mediaRuntimeMocks,
+    getProvider: mediaRuntimeMocks.getVideoGenerationProvider,
+    listProviders: mediaRuntimeMocks.listVideoGenerationProviders,
+    parseModelRef: mediaRuntimeMocks.parseVideoGenerationModelRef,
+  });
+}
+
+function resetSharedRuntimeImportMocks(): void {
+  mediaRuntimeMocks.ensureAuthProfileStore.mockReset();
+  mediaRuntimeMocks.ensureAuthProfileStore.mockReturnValue({ version: 1, profiles: {} });
+  mediaRuntimeMocks.listProfilesForProvider.mockReset();
+  mediaRuntimeMocks.listProfilesForProvider.mockReturnValue([]);
+  mediaRuntimeMocks.resolveEnvApiKey.mockReset();
+  mediaRuntimeMocks.resolveEnvApiKey.mockReturnValue(undefined);
+}

openclaw/test/helpers/media-generation/runtime-test-mocks.ts

@@ -0,0 +1,45 @@
+type ClearableMock = {
+  mockClear(): unknown;
+};
+
+type ResettableMock = {
+  mockReset(): unknown;
+};
+
+type ResettableReturnMock = ResettableMock & {
+  mockReturnValue(value: unknown): unknown;
+};
+
+export type GenerationRuntimeMocks = {
+  createSubsystemLogger: ClearableMock;
+  describeFailoverError: ResettableMock;
+  getProvider: ResettableReturnMock;
+  getProviderEnvVars: ResettableReturnMock;
+  resolveProviderAuthEnvVarCandidates: ResettableReturnMock;
+  isFailoverError: ResettableReturnMock;
+  listProviders: ResettableReturnMock;
+  parseModelRef: ClearableMock;
+  resolveAgentModelFallbackValues: ResettableReturnMock;
+  resolveAgentModelPrimaryValue: ResettableReturnMock;
+  debug: ResettableMock;
+};
+
+export function resetGenerationRuntimeMocks(mocks: GenerationRuntimeMocks): void {
+  mocks.createSubsystemLogger.mockClear();
+  mocks.describeFailoverError.mockReset();
+  mocks.getProvider.mockReset();
+  mocks.getProviderEnvVars.mockReset();
+  mocks.getProviderEnvVars.mockReturnValue([]);
+  mocks.resolveProviderAuthEnvVarCandidates.mockReset();
+  mocks.resolveProviderAuthEnvVarCandidates.mockReturnValue({});
+  mocks.isFailoverError.mockReset();
+  mocks.isFailoverError.mockReturnValue(false);
+  mocks.listProviders.mockReset();
+  mocks.listProviders.mockReturnValue([]);
+  mocks.parseModelRef.mockClear();
+  mocks.resolveAgentModelFallbackValues.mockReset();
+  mocks.resolveAgentModelFallbackValues.mockReturnValue([]);
+  mocks.resolveAgentModelPrimaryValue.mockReset();
+  mocks.resolveAgentModelPrimaryValue.mockReturnValue(undefined);
+  mocks.debug.mockReset();
+}