@full-self-developing/fsd 1.0.0

package/extensions/huggingface/models.ts

@@ -0,0 +1,218 @@
+import type { ModelDefinitionConfig } from "openclaw/plugin-sdk/provider-model-types";
+import {
+  fetchWithSsrFGuard,
+  ssrfPolicyFromHttpBaseUrlAllowedHostname,
+} from "openclaw/plugin-sdk/ssrf-runtime";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isHuggingfaceModelDiscoveryTestEnvironment } from "./model-discovery-env.js";
+
+export const HUGGINGFACE_BASE_URL = "https://router.huggingface.co/v1";
+export const HUGGINGFACE_POLICY_SUFFIXES = ["cheapest", "fastest"] as const;
+export const HUGGINGFACE_DISCOVERY_TIMEOUT_MS = 30_000;
+
+const HUGGINGFACE_DEFAULT_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+};
+
+const HUGGINGFACE_DEFAULT_CONTEXT_WINDOW = 131072;
+const HUGGINGFACE_DEFAULT_MAX_TOKENS = 8192;
+
+type HFModelEntry = {
+  id: string;
+  owned_by?: string;
+  name?: string;
+  title?: string;
+  display_name?: string;
+  architecture?: {
+    input_modalities?: string[];
+  };
+  providers?: Array<{
+    context_length?: number;
+  }>;
+};
+
+type OpenAIListModelsResponse = {
+  data?: HFModelEntry[];
+};
+
+export const HUGGINGFACE_MODEL_CATALOG: ModelDefinitionConfig[] = [
+  {
+    id: "deepseek-ai/DeepSeek-R1",
+    name: "DeepSeek R1",
+    reasoning: true,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 8192,
+    cost: { input: 3.0, output: 7.0, cacheRead: 3.0, cacheWrite: 3.0 },
+  },
+  {
+    id: "deepseek-ai/DeepSeek-V3.1",
+    name: "DeepSeek V3.1",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 8192,
+    cost: { input: 0.6, output: 1.25, cacheRead: 0.6, cacheWrite: 0.6 },
+  },
+  {
+    id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+    name: "Llama 3.3 70B Instruct Turbo",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 8192,
+    cost: { input: 0.88, output: 0.88, cacheRead: 0.88, cacheWrite: 0.88 },
+  },
+  {
+    id: "openai/gpt-oss-120b",
+    name: "GPT-OSS 120B",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 131072,
+    maxTokens: 8192,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  },
+];
+
+export function isHuggingfacePolicyLocked(modelRef: string): boolean {
+  const ref = modelRef.trim();
+  return HUGGINGFACE_POLICY_SUFFIXES.some((suffix) => ref.endsWith(`:${suffix}`) || ref === suffix);
+}
+
+export function buildHuggingfaceModelDefinition(
+  model: (typeof HUGGINGFACE_MODEL_CATALOG)[number],
+): ModelDefinitionConfig {
+  return {
+    id: model.id,
+    name: model.name,
+    reasoning: model.reasoning,
+    input: model.input,
+    cost: model.cost,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+  };
+}
+
+function isReasoningModelHeuristic(modelId: string): boolean {
+  const lower = normalizeLowercaseStringOrEmpty(modelId);
+  return (
+    lower.includes("r1") ||
+    lower.includes("reason") ||
+    lower.includes("thinking") ||
+    lower.includes("reasoner") ||
+    lower.includes("grok") ||
+    lower.includes("qwq")
+  );
+}
+
+function inferredMetaFromModelId(id: string): { name: string; reasoning: boolean } {
+  const base = id.split("/").pop() ?? id;
+  const reasoning = isReasoningModelHeuristic(id);
+  const name = base.replace(/-/g, " ").replace(/\b(\w)/g, (c) => c.toUpperCase());
+  return { name, reasoning };
+}
+
+function displayNameFromApiEntry(entry: HFModelEntry, inferredName: string): string {
+  const fromApi =
+    (typeof entry.name === "string" && entry.name.trim()) ||
+    (typeof entry.title === "string" && entry.title.trim()) ||
+    (typeof entry.display_name === "string" && entry.display_name.trim());
+  if (fromApi) {
+    return fromApi;
+  }
+  if (typeof entry.owned_by === "string" && entry.owned_by.trim()) {
+    const base = entry.id.split("/").pop() ?? entry.id;
+    return `${entry.owned_by.trim()}/${base}`;
+  }
+  return inferredName;
+}
+
+export async function discoverHuggingfaceModels(
+  apiKey: string,
+  timeoutMs = HUGGINGFACE_DISCOVERY_TIMEOUT_MS,
+): Promise<ModelDefinitionConfig[]> {
+  if (isHuggingfaceModelDiscoveryTestEnvironment()) {
+    return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+  }
+
+  const trimmedKey = apiKey?.trim();
+  if (!trimmedKey) {
+    return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+  }
+
+  try {
+    const { response, release } = await fetchWithSsrFGuard({
+      url: `${HUGGINGFACE_BASE_URL}/models`,
+      init: {
+        signal: AbortSignal.timeout(timeoutMs),
+        headers: {
+          Authorization: `Bearer ${trimmedKey}`,
+          "Content-Type": "application/json",
+        },
+      },
+      policy: ssrfPolicyFromHttpBaseUrlAllowedHostname(HUGGINGFACE_BASE_URL),
+      auditContext: "huggingface-model-discovery",
+    });
+    try {
+      if (!response.ok) {
+        return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+      }
+
+      const body = (await response.json()) as OpenAIListModelsResponse;
+      const data = body?.data;
+      if (!Array.isArray(data) || data.length === 0) {
+        return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+      }
+
+      const catalogById = new Map(
+        HUGGINGFACE_MODEL_CATALOG.map((model) => [model.id, model] as const),
+      );
+      const seen = new Set<string>();
+      const models: ModelDefinitionConfig[] = [];
+
+      for (const entry of data) {
+        const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+        if (!id || seen.has(id)) {
+          continue;
+        }
+        seen.add(id);
+
+        const catalogEntry = catalogById.get(id);
+        if (catalogEntry) {
+          models.push(buildHuggingfaceModelDefinition(catalogEntry));
+          continue;
+        }
+
+        const inferred = inferredMetaFromModelId(id);
+        const name = displayNameFromApiEntry(entry, inferred.name);
+        const modalities = entry.architecture?.input_modalities;
+        const input: Array<"text" | "image"> =
+          Array.isArray(modalities) && modalities.includes("image") ? ["text", "image"] : ["text"];
+        const providers = Array.isArray(entry.providers) ? entry.providers : [];
+        const providerWithContext = providers.find(
+          (provider) => typeof provider?.context_length === "number" && provider.context_length > 0,
+        );
+        models.push({
+          id,
+          name,
+          reasoning: inferred.reasoning,
+          input,
+          cost: HUGGINGFACE_DEFAULT_COST,
+          contextWindow: providerWithContext?.context_length ?? HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
+          maxTokens: HUGGINGFACE_DEFAULT_MAX_TOKENS,
+        });
+      }
+
+      return models.length > 0
+        ? models
+        : HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+    } finally {
+      await release();
+    }
+  } catch {
+    return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+  }
+}

package/extensions/huggingface/onboard.ts

@@ -0,0 +1,26 @@
+import {
+  createModelCatalogPresetAppliers,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+import {
+  buildHuggingfaceModelDefinition,
+  HUGGINGFACE_BASE_URL,
+  HUGGINGFACE_MODEL_CATALOG,
+} from "./models.js";
+
+export const HUGGINGFACE_DEFAULT_MODEL_REF = "huggingface/deepseek-ai/DeepSeek-R1";
+
+const huggingfacePresetAppliers = createModelCatalogPresetAppliers({
+  primaryModelRef: HUGGINGFACE_DEFAULT_MODEL_REF,
+  resolveParams: (_cfg: OpenClawConfig) => ({
+    providerId: "huggingface",
+    api: "openai-completions",
+    baseUrl: HUGGINGFACE_BASE_URL,
+    catalogModels: HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition),
+    aliases: [{ modelRef: HUGGINGFACE_DEFAULT_MODEL_REF, alias: "Hugging Face" }],
+  }),
+});
+
+export function applyHuggingfaceConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return huggingfacePresetAppliers.applyConfig(cfg);
+}

package/extensions/huggingface/openclaw.plugin.json

@@ -0,0 +1,57 @@
+{
+  "id": "huggingface",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["huggingface"],
+  "modelIdNormalization": {
+    "providers": {
+      "huggingface": {
+        "stripPrefixes": ["huggingface/"]
+      }
+    }
+  },
+  "providerAuthEnvVars": {
+    "huggingface": ["HUGGINGFACE_HUB_TOKEN", "HF_TOKEN"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "huggingface",
+      "method": "api-key",
+      "choiceId": "huggingface-api-key",
+      "choiceLabel": "Hugging Face API key",
+      "choiceHint": "Inference API (HF token)",
+      "groupId": "huggingface",
+      "groupLabel": "Hugging Face",
+      "groupHint": "Inference API (HF token)",
+      "optionKey": "huggingfaceApiKey",
+      "cliFlag": "--huggingface-api-key",
+      "cliOption": "--huggingface-api-key <key>",
+      "cliDescription": "Hugging Face API key (HF token)"
+    }
+  ],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "discovery": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean" }
+        }
+      }
+    }
+  },
+  "uiHints": {
+    "discovery": {
+      "label": "Model Discovery",
+      "help": "Plugin-owned controls for Hugging Face model auto-discovery."
+    },
+    "discovery.enabled": {
+      "label": "Enable Discovery",
+      "help": "When false, OpenClaw keeps the Hugging Face plugin available but skips implicit startup discovery from ambient Hugging Face credentials."
+    }
+  }
+}

package/extensions/huggingface/package.json

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

package/extensions/huggingface/provider-catalog.ts

@@ -0,0 +1,22 @@
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-types";
+import {
+  buildHuggingfaceModelDefinition,
+  discoverHuggingfaceModels,
+  HUGGINGFACE_BASE_URL,
+  HUGGINGFACE_MODEL_CATALOG,
+} from "./models.js";
+
+export async function buildHuggingfaceProvider(
+  discoveryApiKey?: string,
+): Promise<ModelProviderConfig> {
+  const resolvedSecret = discoveryApiKey?.trim() ?? "";
+  const models =
+    resolvedSecret !== ""
+      ? await discoverHuggingfaceModels(resolvedSecret)
+      : HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+  return {
+    baseUrl: HUGGINGFACE_BASE_URL,
+    api: "openai-completions",
+    models,
+  };
+}

package/extensions/huggingface/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/image-generation-core/api.ts

@@ -0,0 +1,30 @@
+export type { AuthProfileStore } from "openclaw/plugin-sdk/image-generation-core";
+export {
+  buildNoCapabilityModelConfiguredMessage,
+  createSubsystemLogger,
+  describeFailoverError,
+  getImageGenerationProvider,
+  getProviderEnvVars,
+  isFailoverError,
+  listImageGenerationProviders,
+  normalizeGoogleModelId,
+  OPENAI_DEFAULT_IMAGE_MODEL,
+  parseImageGenerationModelRef,
+  resolveAgentModelFallbackValues,
+  resolveAgentModelPrimaryValue,
+  resolveApiKeyForProvider,
+  resolveCapabilityModelCandidates,
+  throwCapabilityGenerationFailure,
+} from "openclaw/plugin-sdk/image-generation-core";
+export type {
+  FallbackAttempt,
+  GeneratedImageAsset,
+  ImageGenerationProvider,
+  ImageGenerationProviderConfiguredContext,
+  ImageGenerationProviderPlugin,
+  ImageGenerationRequest,
+  ImageGenerationResolution,
+  ImageGenerationResult,
+  ImageGenerationSourceImage,
+  OpenClawConfig,
+} from "openclaw/plugin-sdk/image-generation-core";

package/extensions/image-generation-core/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@openclaw/image-generation-core",
+  "version": "2026.5.21",
+  "private": true,
+  "description": "OpenClaw image generation runtime package",
+  "type": "module",
+  "devDependencies": {
+    "@openclaw/plugin-sdk": "workspace:*"
+  }
+}

package/extensions/image-generation-core/runtime-api.ts

@@ -0,0 +1,6 @@
+export {
+  generateImage,
+  listRuntimeImageGenerationProviders,
+  type GenerateImageParams,
+  type GenerateImageRuntimeResult,
+} from "./src/runtime.js";

package/extensions/image-generation-core/src/runtime.test.ts

@@ -0,0 +1,29 @@
+import { afterAll, describe, expect, it, vi } from "vitest";
+
+const sdkExports = vi.hoisted(() => ({
+  generateImage: vi.fn(),
+  listRuntimeImageGenerationProviders: vi.fn(),
+}));
+
+vi.mock("openclaw/plugin-sdk/image-generation-runtime", () => sdkExports);
+
+import {
+  generateImage as sdkGenerateImage,
+  listRuntimeImageGenerationProviders as sdkListRuntimeImageGenerationProviders,
+} from "openclaw/plugin-sdk/image-generation-runtime";
+import { generateImage, listRuntimeImageGenerationProviders } from "./runtime.js";
+
+describe("image-generation-core runtime", () => {
+  afterAll(() => {
+    vi.doUnmock("openclaw/plugin-sdk/image-generation-runtime");
+    vi.resetModules();
+  });
+
+  it("re-exports generateImage from the plugin sdk runtime", () => {
+    expect(generateImage).toBe(sdkGenerateImage);
+  });
+
+  it("re-exports listRuntimeImageGenerationProviders from the plugin sdk runtime", () => {
+    expect(listRuntimeImageGenerationProviders).toBe(sdkListRuntimeImageGenerationProviders);
+  });
+});

package/extensions/image-generation-core/src/runtime.ts

@@ -0,0 +1,6 @@
+export {
+  generateImage,
+  listRuntimeImageGenerationProviders,
+  type GenerateImageParams,
+  type GenerateImageRuntimeResult,
+} from "openclaw/plugin-sdk/image-generation-runtime";

package/extensions/image-generation-core/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/kimi-coding/api.ts

@@ -0,0 +1,8 @@
+export {
+  buildKimiCodingProvider,
+  KIMI_CODING_BASE_URL,
+  KIMI_CODING_DEFAULT_MODEL_ID,
+  KIMI_CODING_LEGACY_MODEL_IDS,
+  normalizeKimiCodingModelId,
+} from "./provider-catalog.js";
+export { KIMI_CODING_MODEL_REF, KIMI_MODEL_REF } from "./onboard.js";

package/extensions/kimi-coding/implicit-provider.test.ts

@@ -0,0 +1,116 @@
+import { registerSingleProviderPlugin } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+
+async function runKimiCatalog(params: {
+  apiKey?: string;
+  explicitProvider?: Record<string, unknown>;
+}) {
+  const provider = await registerSingleProviderPlugin(plugin);
+  const catalogResult = await provider.catalog?.run({
+    config: {
+      models: {
+        providers: params.explicitProvider
+          ? {
+              "kimi-coding": params.explicitProvider,
+            }
+          : {},
+      },
+    },
+    resolveProviderApiKey: () => ({ apiKey: params.apiKey ?? "" }),
+  } as never);
+  return catalogResult ?? null;
+}
+
+async function runKimiCatalogProvider(params: {
+  apiKey: string;
+  explicitProvider?: Record<string, unknown>;
+}) {
+  const result = await runKimiCatalog(params);
+  if (!result || !("provider" in result)) {
+    throw new Error("expected Kimi catalog to return one provider");
+  }
+  return result.provider;
+}
+
+describe("Kimi implicit provider (#22409)", () => {
+  it("publishes the env vars used by core api-key auto-detection", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+
+    expect(provider.envVars).toEqual(["KIMI_API_KEY", "KIMICODE_API_KEY"]);
+  });
+
+  it("does not publish a provider when no API key is resolved", async () => {
+    await expect(runKimiCatalog({})).resolves.toBeNull();
+  });
+
+  it("publishes the Kimi provider when an API key is resolved", async () => {
+    const provider = await runKimiCatalogProvider({ apiKey: "test-key" });
+
+    expect(provider).toEqual({
+      baseUrl: "https://api.kimi.com/coding/",
+      api: "anthropic-messages",
+      headers: {
+        "User-Agent": "claude-code/0.1.0",
+      },
+      models: [
+        {
+          id: "kimi-for-coding",
+          name: "Kimi Code",
+          reasoning: true,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 262144,
+          maxTokens: 32768,
+        },
+        {
+          id: "kimi-code",
+          name: "Kimi Code (legacy kimi-code)",
+          reasoning: true,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 262144,
+          maxTokens: 32768,
+        },
+        {
+          id: "k2p5",
+          name: "Kimi Code (legacy k2p5)",
+          reasoning: true,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 262144,
+          maxTokens: 32768,
+        },
+      ],
+      apiKey: "test-key",
+    });
+  });
+
+  it("uses explicit legacy kimi-coding baseUrl when provided", async () => {
+    const provider = await runKimiCatalogProvider({
+      apiKey: "test-key",
+      explicitProvider: {
+        baseUrl: "https://kimi.example.test/coding/",
+      },
+    });
+
+    expect(provider.baseUrl).toBe("https://kimi.example.test/coding/");
+  });
+
+  it("merges explicit legacy kimi-coding headers on top of the built-in user agent", async () => {
+    const provider = await runKimiCatalogProvider({
+      apiKey: "test-key",
+      explicitProvider: {
+        headers: {
+          "User-Agent": "custom-kimi-client/1.0",
+          "X-Kimi-Tenant": "tenant-a",
+        },
+      },
+    });
+
+    expect(provider.headers).toEqual({
+      "User-Agent": "custom-kimi-client/1.0",
+      "X-Kimi-Tenant": "tenant-a",
+    });
+  });
+});

package/extensions/kimi-coding/index.test.ts

@@ -0,0 +1,45 @@
+import { registerSingleProviderPlugin } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+
+describe("kimi provider plugin", () => {
+  it("normalizes legacy Kimi Code ids to the stable API model id", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+
+    expect(
+      provider.normalizeResolvedModel?.({
+        provider: "kimi",
+        modelId: "kimi-code",
+        model: {
+          id: "kimi-code",
+          name: "Kimi Code",
+          provider: "kimi",
+          api: "anthropic-messages",
+        },
+      } as never),
+    ).toEqual({
+      id: "kimi-for-coding",
+      name: "Kimi Code",
+      provider: "kimi",
+      api: "anthropic-messages",
+    });
+  });
+
+  it("uses binary thinking with thinking off by default", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+
+    expect(
+      provider.resolveThinkingProfile?.({
+        provider: "kimi",
+        modelId: "kimi-code",
+        reasoning: true,
+      } as never),
+    ).toEqual({
+      levels: [
+        { id: "off", label: "off" },
+        { id: "low", label: "on" },
+      ],
+      defaultLevel: "off",
+    });
+  });
+});