@full-self-developing/fsd 1.0.0

package/extensions/azure-speech/tts.ts

@@ -0,0 +1,209 @@
+import { assertOkOrThrowProviderError } from "openclaw/plugin-sdk/provider-http";
+import type { SpeechVoiceOption } from "openclaw/plugin-sdk/speech-core";
+import { trimToUndefined } from "openclaw/plugin-sdk/speech-core";
+import {
+  fetchWithSsrFGuard,
+  ssrfPolicyFromHttpBaseUrlAllowedHostname,
+} from "openclaw/plugin-sdk/ssrf-runtime";
+
+export const DEFAULT_AZURE_SPEECH_VOICE = "en-US-JennyNeural";
+export const DEFAULT_AZURE_SPEECH_LANG = "en-US";
+export const DEFAULT_AZURE_SPEECH_AUDIO_FORMAT = "audio-24khz-48kbitrate-mono-mp3";
+export const DEFAULT_AZURE_SPEECH_VOICE_NOTE_FORMAT = "ogg-24khz-16bit-mono-opus";
+export const DEFAULT_AZURE_SPEECH_TELEPHONY_FORMAT = "raw-8khz-8bit-mono-mulaw";
+
+type AzureSpeechVoiceEntry = {
+  ShortName?: string;
+  DisplayName?: string;
+  LocalName?: string;
+  Locale?: string;
+  Gender?: string;
+  Status?: string;
+  IsDeprecated?: boolean | string;
+  VoiceTag?: {
+    VoicePersonalities?: string[];
+    TailoredScenarios?: string[];
+  };
+};
+
+export function normalizeAzureSpeechBaseUrl(params: {
+  baseUrl?: string;
+  endpoint?: string;
+  region?: string;
+}): string | undefined {
+  const configured = trimToUndefined(params.baseUrl) ?? trimToUndefined(params.endpoint);
+  if (configured) {
+    return configured.replace(/\/+$/, "").replace(/\/cognitiveservices\/v1$/i, "");
+  }
+  const region = trimToUndefined(params.region);
+  return region ? `https://${region}.tts.speech.microsoft.com` : undefined;
+}
+
+function azureSpeechUrl(params: {
+  baseUrl?: string;
+  endpoint?: string;
+  region?: string;
+  path: "/cognitiveservices/v1" | "/cognitiveservices/voices/list";
+}): string {
+  const baseUrl = normalizeAzureSpeechBaseUrl(params);
+  if (!baseUrl) {
+    throw new Error("Azure Speech region or endpoint missing");
+  }
+  return `${baseUrl}${params.path}`;
+}
+
+function escapeXmlText(text: string): string {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function escapeXmlAttr(value: string): string {
+  return escapeXmlText(value).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+export function buildAzureSpeechSsml(params: {
+  text: string;
+  voice: string;
+  lang?: string;
+}): string {
+  const lang = trimToUndefined(params.lang) ?? DEFAULT_AZURE_SPEECH_LANG;
+  return (
+    `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" ` +
+    `xml:lang="${escapeXmlAttr(lang)}">` +
+    `<voice name="${escapeXmlAttr(params.voice)}">${escapeXmlText(params.text)}</voice>` +
+    `</speak>`
+  );
+}
+
+export function inferAzureSpeechFileExtension(outputFormat: string): string {
+  const normalized = outputFormat.toLowerCase();
+  if (normalized.includes("mp3")) {
+    return ".mp3";
+  }
+  if (normalized.startsWith("ogg-")) {
+    return ".ogg";
+  }
+  if (normalized.startsWith("webm-")) {
+    return ".webm";
+  }
+  if (normalized.startsWith("riff-")) {
+    return ".wav";
+  }
+  if (normalized.startsWith("raw-")) {
+    return ".pcm";
+  }
+  if (normalized.startsWith("amr-")) {
+    return ".amr";
+  }
+  return ".audio";
+}
+
+export function isAzureSpeechVoiceCompatible(outputFormat: string): boolean {
+  const normalized = outputFormat.toLowerCase();
+  return normalized.startsWith("ogg-") && normalized.includes("opus");
+}
+
+function formatVoiceDescription(entry: AzureSpeechVoiceEntry): string | undefined {
+  const parts = [
+    ...(entry.VoiceTag?.TailoredScenarios ?? []),
+    ...(entry.VoiceTag?.VoicePersonalities ?? []),
+  ].filter((value) => trimToUndefined(value) !== undefined);
+  return parts.length > 0 ? parts.join(", ") : undefined;
+}
+
+function isDeprecatedVoice(entry: AzureSpeechVoiceEntry): boolean {
+  if (entry.IsDeprecated === true) {
+    return true;
+  }
+  if (typeof entry.IsDeprecated === "string" && entry.IsDeprecated.toLowerCase() === "true") {
+    return true;
+  }
+  const status = trimToUndefined(entry.Status)?.toLowerCase();
+  return status === "deprecated" || status === "retired" || status === "disabled";
+}
+
+export async function listAzureSpeechVoices(params: {
+  apiKey: string;
+  baseUrl?: string;
+  endpoint?: string;
+  region?: string;
+  timeoutMs?: number;
+}): Promise<SpeechVoiceOption[]> {
+  const url = azureSpeechUrl({ ...params, path: "/cognitiveservices/voices/list" });
+  const { response, release } = await fetchWithSsrFGuard({
+    url,
+    init: {
+      method: "GET",
+      headers: {
+        "Ocp-Apim-Subscription-Key": params.apiKey,
+      },
+    },
+    timeoutMs: params.timeoutMs,
+    policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(url),
+    auditContext: "azure-speech.voices",
+  });
+
+  try {
+    await assertOkOrThrowProviderError(response, "Azure Speech voices API error");
+    const voices = (await response.json()) as AzureSpeechVoiceEntry[];
+    return Array.isArray(voices)
+      ? voices
+          .filter((voice) => !isDeprecatedVoice(voice))
+          .map((voice) => ({
+            id: trimToUndefined(voice.ShortName) ?? "",
+            name: trimToUndefined(voice.DisplayName) ?? trimToUndefined(voice.LocalName),
+            description: formatVoiceDescription(voice),
+            locale: trimToUndefined(voice.Locale),
+            gender: trimToUndefined(voice.Gender),
+            personalities: voice.VoiceTag?.VoicePersonalities?.filter(
+              (value): value is string => trimToUndefined(value) !== undefined,
+            ),
+          }))
+          .filter((voice) => voice.id.length > 0)
+      : [];
+  } finally {
+    await release();
+  }
+}
+
+export async function azureSpeechTTS(params: {
+  text: string;
+  apiKey: string;
+  baseUrl?: string;
+  endpoint?: string;
+  region?: string;
+  voice?: string;
+  lang?: string;
+  outputFormat?: string;
+  timeoutMs?: number;
+}): Promise<Buffer> {
+  const voice = trimToUndefined(params.voice) ?? DEFAULT_AZURE_SPEECH_VOICE;
+  const outputFormat = trimToUndefined(params.outputFormat) ?? DEFAULT_AZURE_SPEECH_AUDIO_FORMAT;
+  const url = azureSpeechUrl({ ...params, path: "/cognitiveservices/v1" });
+  const { response, release } = await fetchWithSsrFGuard({
+    url,
+    init: {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/ssml+xml",
+        "Ocp-Apim-Subscription-Key": params.apiKey,
+        "X-Microsoft-OutputFormat": outputFormat,
+        "User-Agent": "OpenClaw",
+      },
+      body: buildAzureSpeechSsml({
+        text: params.text,
+        voice,
+        lang: params.lang,
+      }),
+    },
+    timeoutMs: params.timeoutMs,
+    policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(url),
+    auditContext: "azure-speech.tts",
+  });
+
+  try {
+    await assertOkOrThrowProviderError(response, "Azure Speech TTS API error");
+    return Buffer.from(await response.arrayBuffer());
+  } finally {
+    await release();
+  }
+}

package/extensions/byteplus/api.ts

@@ -0,0 +1,8 @@
+export { buildBytePlusCodingProvider, buildBytePlusProvider } from "./provider-catalog.js";
+export {
+  buildBytePlusModelDefinition,
+  BYTEPLUS_BASE_URL,
+  BYTEPLUS_CODING_BASE_URL,
+  BYTEPLUS_CODING_MODEL_CATALOG,
+  BYTEPLUS_MODEL_CATALOG,
+} from "./models.js";

package/extensions/byteplus/index.test.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { registerSingleProviderPlugin } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+import { BYTEPLUS_CODING_MODEL_CATALOG, BYTEPLUS_MODEL_CATALOG } from "./models.js";
+
+describe("byteplus plugin", () => {
+  it("augments the catalog with bundled standard and plan models", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+    const entries = await provider.augmentModelCatalog?.({
+      env: process.env,
+      entries: [],
+    } as never);
+
+    const standardEntry = entries?.find(
+      (entry) => entry.provider === "byteplus" && entry.id === BYTEPLUS_MODEL_CATALOG[0].id,
+    );
+    expect(standardEntry?.name).toBe(BYTEPLUS_MODEL_CATALOG[0].name);
+    expect(standardEntry?.reasoning).toBe(BYTEPLUS_MODEL_CATALOG[0].reasoning);
+    expect(standardEntry?.input).toEqual([...BYTEPLUS_MODEL_CATALOG[0].input]);
+    expect(standardEntry?.contextWindow).toBe(BYTEPLUS_MODEL_CATALOG[0].contextWindow);
+
+    const planEntry = entries?.find(
+      (entry) =>
+        entry.provider === "byteplus-plan" && entry.id === BYTEPLUS_CODING_MODEL_CATALOG[0].id,
+    );
+    expect(planEntry?.name).toBe(BYTEPLUS_CODING_MODEL_CATALOG[0].name);
+    expect(planEntry?.reasoning).toBe(BYTEPLUS_CODING_MODEL_CATALOG[0].reasoning);
+    expect(planEntry?.input).toEqual([...BYTEPLUS_CODING_MODEL_CATALOG[0].input]);
+    expect(planEntry?.contextWindow).toBe(BYTEPLUS_CODING_MODEL_CATALOG[0].contextWindow);
+  });
+
+  it("declares its coding provider auth alias in the manifest", () => {
+    const pluginJson = JSON.parse(
+      readFileSync(resolve(import.meta.dirname, "openclaw.plugin.json"), "utf-8"),
+    );
+
+    expect(pluginJson.providerAuthAliases).toEqual({
+      "byteplus-plan": "byteplus",
+    });
+  });
+
+  it("keeps Kimi catalog metadata aligned with provider capabilities", () => {
+    const standardKimi = BYTEPLUS_MODEL_CATALOG.find((entry) => entry.id === "kimi-k2-5-260127");
+    const planKimi = BYTEPLUS_CODING_MODEL_CATALOG.find((entry) => entry.id === "kimi-k2.5");
+    const thinkingKimi = BYTEPLUS_CODING_MODEL_CATALOG.find(
+      (entry) => entry.id === "kimi-k2-thinking",
+    );
+
+    for (const entry of [standardKimi, planKimi, thinkingKimi]) {
+      expect(entry?.reasoning).toBe(true);
+      expect(entry?.maxTokens).toBe(32768);
+      expect(entry?.cost?.input).toBe(0.6);
+      expect(entry?.cost?.output).toBe(2.5);
+      expect(entry?.cost?.cacheRead).toBe(0.12);
+      expect(entry?.cost?.cacheWrite).toBe(0);
+    }
+  });
+});

package/extensions/byteplus/index.ts

@@ -0,0 +1,84 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
+import { ensureModelAllowlistEntry } from "openclaw/plugin-sdk/provider-onboard";
+import { BYTEPLUS_CODING_MODEL_CATALOG, BYTEPLUS_MODEL_CATALOG } from "./models.js";
+import { buildBytePlusCodingProvider, buildBytePlusProvider } from "./provider-catalog.js";
+import { buildBytePlusVideoGenerationProvider } from "./video-generation-provider.js";
+
+const PROVIDER_ID = "byteplus";
+const BYTEPLUS_DEFAULT_MODEL_REF = "byteplus-plan/ark-code-latest";
+
+export default definePluginEntry({
+  id: PROVIDER_ID,
+  name: "BytePlus Provider",
+  description: "Bundled BytePlus provider plugin",
+  register(api) {
+    api.registerProvider({
+      id: PROVIDER_ID,
+      label: "BytePlus",
+      docsPath: "/concepts/model-providers#byteplus-international",
+      envVars: ["BYTEPLUS_API_KEY"],
+      auth: [
+        createProviderApiKeyAuthMethod({
+          providerId: PROVIDER_ID,
+          methodId: "api-key",
+          label: "BytePlus API key",
+          hint: "API key",
+          optionKey: "byteplusApiKey",
+          flagName: "--byteplus-api-key",
+          envVar: "BYTEPLUS_API_KEY",
+          promptMessage: "Enter BytePlus API key",
+          defaultModel: BYTEPLUS_DEFAULT_MODEL_REF,
+          expectedProviders: ["byteplus"],
+          applyConfig: (cfg) =>
+            ensureModelAllowlistEntry({
+              cfg,
+              modelRef: BYTEPLUS_DEFAULT_MODEL_REF,
+            }),
+          wizard: {
+            choiceId: "byteplus-api-key",
+            choiceLabel: "BytePlus API key",
+            groupId: "byteplus",
+            groupLabel: "BytePlus",
+            groupHint: "API key",
+          },
+        }),
+      ],
+      catalog: {
+        order: "paired",
+        run: async (ctx) => {
+          const apiKey = ctx.resolveProviderApiKey(PROVIDER_ID).apiKey;
+          if (!apiKey) {
+            return null;
+          }
+          return {
+            providers: {
+              byteplus: { ...buildBytePlusProvider(), apiKey },
+              "byteplus-plan": { ...buildBytePlusCodingProvider(), apiKey },
+            },
+          };
+        },
+      },
+      augmentModelCatalog: () => {
+        const byteplusModels = BYTEPLUS_MODEL_CATALOG.map((entry) => ({
+          provider: "byteplus",
+          id: entry.id,
+          name: entry.name,
+          reasoning: entry.reasoning,
+          input: [...entry.input],
+          contextWindow: entry.contextWindow,
+        }));
+        const byteplusPlanModels = BYTEPLUS_CODING_MODEL_CATALOG.map((entry) => ({
+          provider: "byteplus-plan",
+          id: entry.id,
+          name: entry.name,
+          reasoning: entry.reasoning,
+          input: [...entry.input],
+          contextWindow: entry.contextWindow,
+        }));
+        return [...byteplusModels, ...byteplusPlanModels];
+      },
+    });
+    api.registerVideoGenerationProvider(buildBytePlusVideoGenerationProvider());
+  },
+});

package/extensions/byteplus/live.test.ts

@@ -0,0 +1,60 @@
+import { completeSimple, type Model } from "@earendil-works/pi-ai";
+import {
+  createSingleUserPromptMessage,
+  extractNonEmptyAssistantText,
+  isLiveTestEnabled,
+} from "openclaw/plugin-sdk/test-env";
+import { describe, expect, it } from "vitest";
+import { BYTEPLUS_CODING_BASE_URL, BYTEPLUS_DEFAULT_COST } from "./models.js";
+
+const BYTEPLUS_KEY = process.env.BYTEPLUS_API_KEY ?? "";
+const BYTEPLUS_CODING_MODEL = process.env.BYTEPLUS_CODING_MODEL?.trim() || "ark-code-latest";
+const LIVE = isLiveTestEnabled(["BYTEPLUS_LIVE_TEST"]);
+
+const describeLive = LIVE && BYTEPLUS_KEY ? describe : describe.skip;
+
+function isBytePlusSubscriptionError(message: string): boolean {
+  const lower = message.toLowerCase();
+  return (
+    lower.includes("coding plan subscription") ||
+    lower.includes("subscription has expired") ||
+    (lower.includes("subscription") && lower.includes("renewal"))
+  );
+}
+
+describeLive("byteplus coding plan live", () => {
+  it("returns assistant text", async () => {
+    const model: Model<"openai-completions"> = {
+      id: BYTEPLUS_CODING_MODEL,
+      name: `BytePlus Coding ${BYTEPLUS_CODING_MODEL}`,
+      api: "openai-completions",
+      provider: "byteplus-plan",
+      baseUrl: BYTEPLUS_CODING_BASE_URL,
+      reasoning: false,
+      input: ["text"],
+      cost: BYTEPLUS_DEFAULT_COST,
+      contextWindow: 256000,
+      maxTokens: 4096,
+    };
+
+    const res = await completeSimple(
+      model,
+      {
+        messages: createSingleUserPromptMessage(),
+      },
+      { apiKey: BYTEPLUS_KEY, maxTokens: 64 },
+    );
+
+    if (res.stopReason === "error") {
+      const message = res.errorMessage ?? "";
+      if (isBytePlusSubscriptionError(message)) {
+        expect(message.toLowerCase()).toContain("subscription");
+        return;
+      }
+      throw new Error(message || "byteplus returned error with no message");
+    }
+
+    const text = extractNonEmptyAssistantText(res.content);
+    expect(text.length).toBeGreaterThan(0);
+  }, 30000);
+});

package/extensions/byteplus/models.ts

@@ -0,0 +1,35 @@
+import { buildManifestModelProviderConfig } from "openclaw/plugin-sdk/provider-catalog-shared";
+import type { ModelDefinitionConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import manifest from "./openclaw.plugin.json" with { type: "json" };
+
+const BYTEPLUS_MANIFEST_PROVIDER = buildManifestModelProviderConfig({
+  providerId: "byteplus",
+  catalog: manifest.modelCatalog.providers.byteplus,
+});
+
+const BYTEPLUS_CODING_MANIFEST_PROVIDER = buildManifestModelProviderConfig({
+  providerId: "byteplus-plan",
+  catalog: manifest.modelCatalog.providers["byteplus-plan"],
+});
+
+export const BYTEPLUS_BASE_URL = BYTEPLUS_MANIFEST_PROVIDER.baseUrl;
+export const BYTEPLUS_CODING_BASE_URL = BYTEPLUS_CODING_MANIFEST_PROVIDER.baseUrl;
+
+export const BYTEPLUS_DEFAULT_COST = {
+  input: 0.0001,
+  output: 0.0002,
+  cacheRead: 0,
+  cacheWrite: 0,
+};
+
+export const BYTEPLUS_MODEL_CATALOG: ModelDefinitionConfig[] = BYTEPLUS_MANIFEST_PROVIDER.models;
+export const BYTEPLUS_CODING_MODEL_CATALOG: ModelDefinitionConfig[] =
+  BYTEPLUS_CODING_MANIFEST_PROVIDER.models;
+
+export function buildBytePlusModelDefinition(entry: ModelDefinitionConfig): ModelDefinitionConfig {
+  return {
+    ...entry,
+    input: [...entry.input],
+    cost: { ...entry.cost },
+  };
+}

package/extensions/byteplus/openclaw.plugin.json

@@ -0,0 +1,165 @@
+{
+  "id": "byteplus",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providerCatalogEntry": "./provider-discovery.ts",
+  "providers": ["byteplus", "byteplus-plan"],
+  "providerAuthEnvVars": {
+    "byteplus": ["BYTEPLUS_API_KEY"]
+  },
+  "providerAuthAliases": {
+    "byteplus-plan": "byteplus"
+  },
+  "modelCatalog": {
+    "providers": {
+      "byteplus": {
+        "baseUrl": "https://ark.ap-southeast.bytepluses.com/api/v3",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "seed-1-8-251228",
+            "name": "Seed 1.8",
+            "input": ["text", "image"],
+            "contextWindow": 256000,
+            "maxTokens": 4096,
+            "cost": {
+              "input": 0.0001,
+              "output": 0.0002,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2-5-260127",
+            "name": "Kimi K2.5",
+            "reasoning": true,
+            "input": ["text", "image"],
+            "contextWindow": 256000,
+            "maxTokens": 32768,
+            "cost": {
+              "input": 0.6,
+              "output": 2.5,
+              "cacheRead": 0.12,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "glm-4-7-251222",
+            "name": "GLM 4.7",
+            "input": ["text", "image"],
+            "contextWindow": 200000,
+            "maxTokens": 4096,
+            "cost": {
+              "input": 0.0001,
+              "output": 0.0002,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          }
+        ]
+      },
+      "byteplus-plan": {
+        "baseUrl": "https://ark.ap-southeast.bytepluses.com/api/coding/v3",
+        "api": "openai-completions",
+        "models": [
+          {
+            "id": "ark-code-latest",
+            "name": "Ark Coding Plan",
+            "input": ["text"],
+            "contextWindow": 256000,
+            "maxTokens": 4096,
+            "cost": {
+              "input": 0.0001,
+              "output": 0.0002,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "doubao-seed-code",
+            "name": "Doubao Seed Code",
+            "input": ["text"],
+            "contextWindow": 256000,
+            "maxTokens": 4096,
+            "cost": {
+              "input": 0.0001,
+              "output": 0.0002,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "glm-4.7",
+            "name": "GLM 4.7 Coding",
+            "input": ["text"],
+            "contextWindow": 200000,
+            "maxTokens": 4096,
+            "cost": {
+              "input": 0.0001,
+              "output": 0.0002,
+              "cacheRead": 0,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2-thinking",
+            "name": "Kimi K2 Thinking",
+            "reasoning": true,
+            "input": ["text"],
+            "contextWindow": 256000,
+            "maxTokens": 32768,
+            "cost": {
+              "input": 0.6,
+              "output": 2.5,
+              "cacheRead": 0.12,
+              "cacheWrite": 0
+            }
+          },
+          {
+            "id": "kimi-k2.5",
+            "name": "Kimi K2.5 Coding",
+            "reasoning": true,
+            "input": ["text"],
+            "contextWindow": 256000,
+            "maxTokens": 32768,
+            "cost": {
+              "input": 0.6,
+              "output": 2.5,
+              "cacheRead": 0.12,
+              "cacheWrite": 0
+            }
+          }
+        ]
+      }
+    },
+    "discovery": {
+      "byteplus": "static",
+      "byteplus-plan": "static"
+    }
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "byteplus",
+      "method": "api-key",
+      "choiceId": "byteplus-api-key",
+      "choiceLabel": "BytePlus API key",
+      "groupId": "byteplus",
+      "groupLabel": "BytePlus",
+      "groupHint": "API key",
+      "optionKey": "byteplusApiKey",
+      "cliFlag": "--byteplus-api-key",
+      "cliOption": "--byteplus-api-key <key>",
+      "cliDescription": "BytePlus API key"
+    }
+  ],
+  "contracts": {
+    "videoGenerationProviders": ["byteplus"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/byteplus/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@openclaw/byteplus-provider",
+  "version": "2026.5.21",
+  "private": true,
+  "description": "OpenClaw BytePlus provider plugin",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/extensions/byteplus/plugin-registration.contract.test.ts

@@ -0,0 +1,8 @@
+import { describePluginRegistrationContract } from "openclaw/plugin-sdk/plugin-test-contracts";
+
+describePluginRegistrationContract({
+  pluginId: "byteplus",
+  providerIds: ["byteplus", "byteplus-plan"],
+  videoGenerationProviderIds: ["byteplus"],
+  requireGenerateVideo: true,
+});

package/extensions/byteplus/provider-catalog.ts

@@ -0,0 +1,17 @@
+import { buildManifestModelProviderConfig } from "openclaw/plugin-sdk/provider-catalog-shared";
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import manifest from "./openclaw.plugin.json" with { type: "json" };
+
+export function buildBytePlusProvider(): ModelProviderConfig {
+  return buildManifestModelProviderConfig({
+    providerId: "byteplus",
+    catalog: manifest.modelCatalog.providers.byteplus,
+  });
+}
+
+export function buildBytePlusCodingProvider(): ModelProviderConfig {
+  return buildManifestModelProviderConfig({
+    providerId: "byteplus-plan",
+    catalog: manifest.modelCatalog.providers["byteplus-plan"],
+  });
+}