@full-self-developing/fsd 1.0.0

package/extensions/byteplus/provider-discovery.ts

@@ -0,0 +1,31 @@
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-model-shared";
+import { buildBytePlusCodingProvider, buildBytePlusProvider } from "./provider-catalog.js";
+
+const bytePlusProviderDiscovery: ProviderPlugin[] = [
+  {
+    id: "byteplus",
+    label: "BytePlus",
+    docsPath: "/providers/models",
+    auth: [],
+    staticCatalog: {
+      order: "simple",
+      run: async () => ({
+        provider: buildBytePlusProvider(),
+      }),
+    },
+  },
+  {
+    id: "byteplus-plan",
+    label: "BytePlus Plan",
+    docsPath: "/providers/models",
+    auth: [],
+    staticCatalog: {
+      order: "simple",
+      run: async () => ({
+        provider: buildBytePlusCodingProvider(),
+      }),
+    },
+  },
+];
+
+export default bytePlusProviderDiscovery;

package/extensions/byteplus/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"
+  ]
+}

package/extensions/byteplus/video-generation-provider.test.ts

@@ -0,0 +1,223 @@
+import {
+  getProviderHttpMocks,
+  installProviderHttpMockCleanup,
+} from "openclaw/plugin-sdk/provider-http-test-mocks";
+import { expectExplicitVideoGenerationCapabilities } from "openclaw/plugin-sdk/provider-test-contracts";
+import { beforeAll, describe, expect, it, vi } from "vitest";
+
+const { postJsonRequestMock, fetchWithTimeoutMock } = getProviderHttpMocks();
+
+let buildBytePlusVideoGenerationProvider: typeof import("./video-generation-provider.js").buildBytePlusVideoGenerationProvider;
+
+beforeAll(async () => {
+  ({ buildBytePlusVideoGenerationProvider } = await import("./video-generation-provider.js"));
+});
+
+installProviderHttpMockCleanup();
+
+function mockSuccessfulBytePlusTask(params?: { model?: string }) {
+  postJsonRequestMock.mockResolvedValue({
+    response: {
+      json: async () => ({
+        id: "task_123",
+      }),
+    },
+    release: vi.fn(async () => {}),
+  });
+  fetchWithTimeoutMock
+    .mockResolvedValueOnce({
+      json: async () => ({
+        id: "task_123",
+        status: "succeeded",
+        content: {
+          video_url: "https://example.com/byteplus.mp4",
+        },
+        model: params?.model ?? "seedance-1-0-lite-t2v-250428",
+      }),
+    })
+    .mockResolvedValueOnce({
+      headers: new Headers({ "content-type": "video/webm" }),
+      arrayBuffer: async () => Buffer.from("webm-bytes"),
+    });
+}
+
+function requireBytePlusPostRequest(): { body?: Record<string, unknown>; url?: string } {
+  const [call] = postJsonRequestMock.mock.calls;
+  if (!call) {
+    throw new Error("expected BytePlus video request");
+  }
+  const [request] = call;
+  if (!request) {
+    throw new Error("expected BytePlus video request");
+  }
+  if (typeof request !== "object" || Array.isArray(request)) {
+    throw new Error("expected BytePlus video request options");
+  }
+  return request as { body?: Record<string, unknown>; url?: string };
+}
+
+function requireBytePlusPostBody(): Record<string, unknown> {
+  const request = requireBytePlusPostRequest();
+  if (!request.body) {
+    throw new Error("expected BytePlus video request body");
+  }
+  return request.body;
+}
+
+describe("byteplus video generation provider", () => {
+  it("declares explicit mode capabilities", () => {
+    expectExplicitVideoGenerationCapabilities(buildBytePlusVideoGenerationProvider());
+  });
+
+  it("creates a content-generation task, polls, and downloads the video", async () => {
+    mockSuccessfulBytePlusTask();
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    const result = await provider.generateVideo({
+      provider: "byteplus",
+      model: "seedance-1-0-lite-t2v-250428",
+      prompt: "A lantern floats upward into the night sky",
+      cfg: {},
+    });
+
+    expect(postJsonRequestMock).toHaveBeenCalledTimes(1);
+    const request = requireBytePlusPostRequest();
+    expect(request.url).toBe(
+      "https://ark.ap-southeast.bytepluses.com/api/v3/contents/generations/tasks",
+    );
+    expect(result.videos).toHaveLength(1);
+    const [video] = result.videos;
+    if (!video) {
+      throw new Error("Expected generated BytePlus video");
+    }
+    expect(video.fileName).toBe("video-1.webm");
+    const metadata = result.metadata as Record<string, unknown>;
+    expect(metadata.taskId).toBe("task_123");
+  });
+
+  it("switches t2v image requests to i2v models and lowercases resolution", async () => {
+    mockSuccessfulBytePlusTask({ model: "seedance-1-0-lite-i2v-250428" });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await provider.generateVideo({
+      provider: "byteplus",
+      model: "seedance-1-0-lite-t2v-250428",
+      prompt: "Animate this still image",
+      resolution: "720P",
+      inputImages: [{ url: "https://example.com/first-frame.png" }],
+      cfg: {},
+    });
+
+    expect(requireBytePlusPostBody()).toEqual({
+      model: "seedance-1-0-lite-i2v-250428",
+      resolution: "720p",
+      content: [
+        { type: "text", text: "Animate this still image" },
+        {
+          type: "image_url",
+          image_url: { url: "https://example.com/first-frame.png" },
+          role: "first_frame",
+        },
+      ],
+    });
+  });
+
+  it("maps declared providerOptions into the request body", async () => {
+    mockSuccessfulBytePlusTask({ model: "seedance-1-0-pro-250528" });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await provider.generateVideo({
+      provider: "byteplus",
+      model: "seedance-1-0-pro-250528",
+      prompt: "A cinematic lobster montage",
+      providerOptions: {
+        seed: 42,
+        draft: true,
+        camera_fixed: false,
+      },
+      cfg: {},
+    });
+
+    const body = requireBytePlusPostBody();
+    expect(body.model).toBe("seedance-1-0-pro-250528");
+    expect(body.seed).toBe(42);
+    expect(body.resolution).toBe("480p");
+    expect(body.camera_fixed).toBe(false);
+  });
+
+  it("reports malformed create JSON with a provider-owned error", async () => {
+    const release = vi.fn(async () => {});
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => {
+          throw new SyntaxError("bad json");
+        },
+      },
+      release,
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "bad create response",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video generation failed: malformed JSON response");
+    expect(release).toHaveBeenCalledOnce();
+  });
+
+  it("rejects status responses missing a task status", async () => {
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({ id: "task_missing_status" }),
+      },
+      release: vi.fn(async () => {}),
+    });
+    fetchWithTimeoutMock.mockResolvedValueOnce({
+      json: async () => ({
+        id: "task_missing_status",
+        content: {
+          video_url: "https://example.com/byteplus.mp4",
+        },
+      }),
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "missing status",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video status response missing task status");
+  });
+
+  it("rejects malformed completed content", async () => {
+    postJsonRequestMock.mockResolvedValue({
+      response: {
+        json: async () => ({ id: "task_malformed_content" }),
+      },
+      release: vi.fn(async () => {}),
+    });
+    fetchWithTimeoutMock.mockResolvedValueOnce({
+      json: async () => ({
+        id: "task_malformed_content",
+        status: "succeeded",
+        content: ["https://example.com/byteplus.mp4"],
+      }),
+    });
+
+    const provider = buildBytePlusVideoGenerationProvider();
+    await expect(
+      provider.generateVideo({
+        provider: "byteplus",
+        model: "seedance-1-0-lite-t2v-250428",
+        prompt: "malformed content",
+        cfg: {},
+      }),
+    ).rejects.toThrow("BytePlus video generation completed with malformed content");
+  });
+});

package/extensions/byteplus/video-generation-provider.ts

@@ -0,0 +1,389 @@
+import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
+import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
+import { resolveApiKeyForProvider } from "openclaw/plugin-sdk/provider-auth-runtime";
+import {
+  assertOkOrThrowHttpError,
+  createProviderOperationDeadline,
+  createProviderOperationTimeoutResolver,
+  fetchProviderDownloadResponse,
+  fetchProviderOperationResponse,
+  postJsonRequest,
+  resolveProviderOperationTimeoutMs,
+  resolveProviderHttpRequestConfig,
+  waitProviderOperationPollInterval,
+  type ProviderOperationTimeoutMs,
+} from "openclaw/plugin-sdk/provider-http";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import type {
+  GeneratedVideoAsset,
+  VideoGenerationProvider,
+  VideoGenerationRequest,
+} from "openclaw/plugin-sdk/video-generation";
+import { BYTEPLUS_BASE_URL } from "./models.js";
+
+const DEFAULT_BYTEPLUS_VIDEO_MODEL = "seedance-1-0-lite-t2v-250428";
+const DEFAULT_TIMEOUT_MS = 120_000;
+const POLL_INTERVAL_MS = 5_000;
+const MAX_POLL_ATTEMPTS = 120;
+
+type BytePlusTaskCreateResponse = {
+  id?: unknown;
+};
+
+type BytePlusTaskResponse = {
+  id?: unknown;
+  model?: unknown;
+  status?: unknown;
+  error?: unknown;
+  content?: unknown;
+  duration?: unknown;
+  ratio?: unknown;
+  resolution?: unknown;
+};
+
+type BytePlusTaskStatus = "running" | "failed" | "queued" | "succeeded" | "cancelled";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+async function readBytePlusJsonResponse<T>(
+  response: Pick<Response, "json">,
+  label: string,
+): Promise<T> {
+  let payload: unknown;
+  try {
+    payload = await response.json();
+  } catch (cause) {
+    throw new Error(`${label}: malformed JSON response`, { cause });
+  }
+  if (!isRecord(payload)) {
+    throw new Error(`${label}: malformed JSON response`);
+  }
+  return payload as T;
+}
+
+function readBytePlusTaskStatus(payload: BytePlusTaskResponse): BytePlusTaskStatus {
+  const status = normalizeOptionalString(payload.status);
+  switch (status) {
+    case "running":
+    case "failed":
+    case "queued":
+    case "succeeded":
+    case "cancelled":
+      return status;
+    case undefined:
+      throw new Error("BytePlus video status response missing task status");
+    default:
+      throw new Error(`BytePlus video status response returned unknown task status: ${status}`);
+  }
+}
+
+function readBytePlusErrorMessage(error: unknown): string | undefined {
+  return isRecord(error) ? normalizeOptionalString(error.message) : undefined;
+}
+
+function readBytePlusVideoUrl(payload: BytePlusTaskResponse): string {
+  const content = payload.content;
+  if (content !== undefined && !isRecord(content)) {
+    throw new Error("BytePlus video generation completed with malformed content");
+  }
+  const videoUrl = normalizeOptionalString(content?.video_url);
+  if (!videoUrl) {
+    throw new Error("BytePlus video generation completed without a video URL");
+  }
+  return videoUrl;
+}
+
+function resolveBytePlusVideoBaseUrl(req: VideoGenerationRequest): string {
+  return (
+    normalizeOptionalString(req.cfg?.models?.providers?.byteplus?.baseUrl) ?? BYTEPLUS_BASE_URL
+  );
+}
+
+function toDataUrl(buffer: Buffer, mimeType: string): string {
+  return `data:${mimeType};base64,${buffer.toString("base64")}`;
+}
+
+function resolveBytePlusImageUrl(req: VideoGenerationRequest): string | undefined {
+  const input = req.inputImages?.[0];
+  if (!input) {
+    return undefined;
+  }
+  const inputUrl = normalizeOptionalString(input.url);
+  if (inputUrl) {
+    return inputUrl;
+  }
+  if (!input.buffer) {
+    throw new Error("BytePlus reference image is missing image data.");
+  }
+  return toDataUrl(input.buffer, normalizeOptionalString(input.mimeType) ?? "image/png");
+}
+
+async function pollBytePlusTask(params: {
+  taskId: string;
+  headers: Headers;
+  timeoutMs?: number;
+  baseUrl: string;
+  fetchFn: typeof fetch;
+}): Promise<BytePlusTaskResponse> {
+  const deadline = createProviderOperationDeadline({
+    timeoutMs: params.timeoutMs,
+    label: `BytePlus video generation task ${params.taskId}`,
+  });
+  for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt += 1) {
+    const response = await fetchProviderOperationResponse({
+      stage: "poll",
+      url: `${params.baseUrl}/contents/generations/tasks/${params.taskId}`,
+      init: {
+        method: "GET",
+        headers: params.headers,
+      },
+      timeoutMs: createProviderOperationTimeoutResolver({
+        deadline,
+        defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+      }),
+      fetchFn: params.fetchFn,
+      provider: "byteplus",
+      requestFailedMessage: "BytePlus video status request failed",
+    });
+    const payload = await readBytePlusJsonResponse<BytePlusTaskResponse>(
+      response,
+      "BytePlus video status request failed",
+    );
+    switch (readBytePlusTaskStatus(payload)) {
+      case "succeeded":
+        return payload;
+      case "failed":
+      case "cancelled":
+        throw new Error(
+          readBytePlusErrorMessage(payload.error) || "BytePlus video generation failed",
+        );
+      case "queued":
+      case "running":
+      default:
+        await waitProviderOperationPollInterval({ deadline, pollIntervalMs: POLL_INTERVAL_MS });
+        break;
+    }
+  }
+  throw new Error(`BytePlus video generation task ${params.taskId} did not finish in time`);
+}
+
+async function downloadBytePlusVideo(params: {
+  url: string;
+  timeoutMs?: ProviderOperationTimeoutMs;
+  fetchFn: typeof fetch;
+}): Promise<GeneratedVideoAsset> {
+  const response = await fetchProviderDownloadResponse({
+    url: params.url,
+    init: { method: "GET" },
+    timeoutMs: params.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    fetchFn: params.fetchFn,
+    provider: "byteplus",
+    requestFailedMessage: "BytePlus generated video download failed",
+  });
+  const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "video/mp4";
+  const arrayBuffer = await response.arrayBuffer();
+  return {
+    buffer: Buffer.from(arrayBuffer),
+    mimeType,
+    fileName: `video-1.${extensionForMime(mimeType)?.slice(1) ?? "mp4"}`,
+  };
+}
+
+export function buildBytePlusVideoGenerationProvider(): VideoGenerationProvider {
+  return {
+    id: "byteplus",
+    label: "BytePlus",
+    defaultModel: DEFAULT_BYTEPLUS_VIDEO_MODEL,
+    models: [
+      DEFAULT_BYTEPLUS_VIDEO_MODEL,
+      "seedance-1-0-lite-i2v-250428",
+      "seedance-1-0-pro-250528",
+      "seedance-1-5-pro-251215",
+    ],
+    isConfigured: ({ agentDir }) =>
+      isProviderApiKeyConfigured({
+        provider: "byteplus",
+        agentDir,
+      }),
+    capabilities: {
+      providerOptions: {
+        seed: "number",
+        draft: "boolean",
+        camera_fixed: "boolean",
+      },
+      generate: {
+        maxVideos: 1,
+        maxDurationSeconds: 12,
+        supportsAspectRatio: true,
+        supportsResolution: true,
+        supportsAudio: true,
+        supportsWatermark: true,
+      },
+      imageToVideo: {
+        enabled: true,
+        maxVideos: 1,
+        maxInputImages: 1,
+        maxDurationSeconds: 12,
+        supportsAspectRatio: true,
+        supportsResolution: true,
+        supportsAudio: true,
+        supportsWatermark: true,
+      },
+      videoToVideo: {
+        enabled: false,
+      },
+    },
+    async generateVideo(req) {
+      if ((req.inputVideos?.length ?? 0) > 0) {
+        throw new Error("BytePlus video generation does not support video reference inputs.");
+      }
+      const auth = await resolveApiKeyForProvider({
+        provider: "byteplus",
+        cfg: req.cfg,
+        agentDir: req.agentDir,
+        store: req.authStore,
+      });
+      if (!auth.apiKey) {
+        throw new Error("BytePlus API key missing");
+      }
+
+      const fetchFn = fetch;
+      const deadline = createProviderOperationDeadline({
+        timeoutMs: req.timeoutMs,
+        label: "BytePlus video generation",
+      });
+      const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } =
+        resolveProviderHttpRequestConfig({
+          baseUrl: resolveBytePlusVideoBaseUrl(req),
+          defaultBaseUrl: BYTEPLUS_BASE_URL,
+          allowPrivateNetwork: false,
+          defaultHeaders: {
+            Authorization: `Bearer ${auth.apiKey}`,
+            "Content-Type": "application/json",
+          },
+          provider: "byteplus",
+          capability: "video",
+          transport: "http",
+        });
+      // Seedance 1.0 has separate T2V and I2V model IDs (e.g. seedance-1-0-lite-t2v-250428 vs
+      // seedance-1-0-lite-i2v-250428). When input images are provided with a T2V model, auto-
+      // switch to the corresponding I2V variant so the API does not reject with task_type mismatch.
+      // 1.5 Pro uses a single model ID for both modes and is unaffected by this substitution.
+      const hasInputImages = (req.inputImages?.length ?? 0) > 0;
+      const requestedModel = normalizeOptionalString(req.model) || DEFAULT_BYTEPLUS_VIDEO_MODEL;
+      const resolvedModel =
+        hasInputImages && requestedModel.includes("-t2v-")
+          ? requestedModel.replace("-t2v-", "-i2v-")
+          : requestedModel;
+
+      const content: Array<Record<string, unknown>> = [{ type: "text", text: req.prompt }];
+      const imageUrl = resolveBytePlusImageUrl(req);
+      if (imageUrl) {
+        content.push({
+          type: "image_url",
+          image_url: { url: imageUrl },
+          role: "first_frame",
+        });
+      }
+      const body: Record<string, unknown> = {
+        model: resolvedModel,
+        content,
+      };
+      const aspectRatio = normalizeOptionalString(req.aspectRatio);
+      if (aspectRatio) {
+        body.ratio = aspectRatio;
+      }
+      // Seedance API requires lowercase resolution values (e.g. "480p", "720p"); uppercase
+      // variants like "480P" are rejected with InvalidParameter.
+      const resolution = normalizeOptionalString(req.resolution)?.toLowerCase();
+      if (resolution) {
+        body.resolution = resolution;
+      }
+      if (typeof req.durationSeconds === "number" && Number.isFinite(req.durationSeconds)) {
+        body.duration = Math.max(1, Math.round(req.durationSeconds));
+      }
+      if (typeof req.audio === "boolean") {
+        body.generate_audio = req.audio;
+      }
+      if (typeof req.watermark === "boolean") {
+        body.watermark = req.watermark;
+      }
+
+      // Forward declared providerOptions: seed, draft, camerafixed.
+      // draft=true forces 480p resolution for faster generation.
+      const opts = req.providerOptions ?? {};
+      const seed = typeof opts.seed === "number" ? opts.seed : undefined;
+      const draft = opts.draft === true;
+      // Official JSON body field is camera_fixed (with underscore).
+      const cameraFixed = typeof opts.camera_fixed === "boolean" ? opts.camera_fixed : undefined;
+      if (seed != null) {
+        body.seed = seed;
+      }
+      if (draft && !body.resolution) {
+        body.resolution = "480p";
+      }
+      if (cameraFixed != null) {
+        body.camera_fixed = cameraFixed;
+      }
+
+      const { response, release } = await postJsonRequest({
+        url: `${baseUrl}/contents/generations/tasks`,
+        headers,
+        body,
+        timeoutMs: resolveProviderOperationTimeoutMs({
+          deadline,
+          defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+        }),
+        fetchFn,
+        allowPrivateNetwork,
+        dispatcherPolicy,
+      });
+      try {
+        await assertOkOrThrowHttpError(response, "BytePlus video generation failed");
+        const submitted = await readBytePlusJsonResponse<BytePlusTaskCreateResponse>(
+          response,
+          "BytePlus video generation failed",
+        );
+        const taskId = normalizeOptionalString(submitted.id);
+        if (!taskId) {
+          throw new Error("BytePlus video generation response missing task id");
+        }
+        const completed = await pollBytePlusTask({
+          taskId,
+          headers,
+          timeoutMs: resolveProviderOperationTimeoutMs({
+            deadline,
+            defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+          }),
+          baseUrl,
+          fetchFn,
+        });
+        const videoUrl = readBytePlusVideoUrl(completed);
+        const video = await downloadBytePlusVideo({
+          url: videoUrl,
+          timeoutMs: createProviderOperationTimeoutResolver({
+            deadline,
+            defaultTimeoutMs: DEFAULT_TIMEOUT_MS,
+          }),
+          fetchFn,
+        });
+        return {
+          videos: [video],
+          model: normalizeOptionalString(completed.model) ?? resolvedModel,
+          metadata: {
+            taskId,
+            status: normalizeOptionalString(completed.status),
+            videoUrl,
+            ratio: normalizeOptionalString(completed.ratio),
+            resolution: normalizeOptionalString(completed.resolution),
+            duration: typeof completed.duration === "number" ? completed.duration : undefined,
+          },
+        };
+      } finally {
+        await release();
+      }
+    },
+  };
+}

package/extensions/cerebras/api.ts

@@ -0,0 +1,7 @@
+export {
+  buildCerebrasModelDefinition,
+  CEREBRAS_BASE_URL,
+  CEREBRAS_MODEL_CATALOG,
+} from "./models.js";
+export { buildCerebrasProvider } from "./provider-catalog.js";
+export { applyCerebrasConfig, CEREBRAS_DEFAULT_MODEL_REF } from "./onboard.js";