@full-self-developing/fsd 1.0.0

package/extensions/litellm/onboard.test.ts

@@ -0,0 +1,21 @@
+import { expectProviderOnboardMergedLegacyConfig } from "openclaw/plugin-sdk/provider-test-contracts";
+import { describe, expect, it } from "vitest";
+import { applyLitellmProviderConfig } from "./onboard.js";
+
+describe("litellm onboard", () => {
+  it("preserves existing baseUrl and api key while adding the default model", () => {
+    const provider = expectProviderOnboardMergedLegacyConfig({
+      applyProviderConfig: applyLitellmProviderConfig,
+      providerId: "litellm",
+      providerApi: "openai-completions",
+      baseUrl: "https://litellm.example/v1",
+      legacyApi: "anthropic-messages",
+      legacyModelId: "custom-model",
+      legacyModelName: "Custom",
+      legacyBaseUrl: "https://litellm.example/v1",
+      legacyApiKey: "  old-key  ",
+    });
+
+    expect(provider?.models.map((m) => m.id)).toEqual(["custom-model", "claude-opus-4-6"]);
+  });
+});

package/extensions/litellm/onboard.ts

@@ -0,0 +1,55 @@
+import {
+  createDefaultModelPresetAppliers,
+  type ModelDefinitionConfig,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+
+export const LITELLM_BASE_URL = "http://localhost:4000";
+export const LITELLM_DEFAULT_MODEL_ID = "claude-opus-4-6";
+export const LITELLM_DEFAULT_MODEL_REF = `litellm/${LITELLM_DEFAULT_MODEL_ID}`;
+const LITELLM_DEFAULT_CONTEXT_WINDOW = 128_000;
+const LITELLM_DEFAULT_MAX_TOKENS = 8_192;
+const LITELLM_DEFAULT_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+};
+
+export function buildLitellmModelDefinition(): ModelDefinitionConfig {
+  return {
+    id: LITELLM_DEFAULT_MODEL_ID,
+    name: "Claude Opus 4.6",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: LITELLM_DEFAULT_COST,
+    contextWindow: LITELLM_DEFAULT_CONTEXT_WINDOW,
+    maxTokens: LITELLM_DEFAULT_MAX_TOKENS,
+  };
+}
+
+const litellmPresetAppliers = createDefaultModelPresetAppliers({
+  primaryModelRef: LITELLM_DEFAULT_MODEL_REF,
+  resolveParams: (cfg: OpenClawConfig) => {
+    const existingProvider = cfg.models?.providers?.litellm as { baseUrl?: unknown } | undefined;
+    const resolvedBaseUrl =
+      typeof existingProvider?.baseUrl === "string" ? existingProvider.baseUrl.trim() : "";
+
+    return {
+      providerId: "litellm",
+      api: "openai-completions" as const,
+      baseUrl: resolvedBaseUrl || LITELLM_BASE_URL,
+      defaultModel: buildLitellmModelDefinition(),
+      defaultModelId: LITELLM_DEFAULT_MODEL_ID,
+      aliases: [{ modelRef: LITELLM_DEFAULT_MODEL_REF, alias: "LiteLLM" }],
+    };
+  },
+});
+
+export function applyLitellmProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return litellmPresetAppliers.applyProviderConfig(cfg);
+}
+
+export function applyLitellmConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return litellmPresetAppliers.applyConfig(cfg);
+}

package/extensions/litellm/openclaw.plugin.json

@@ -0,0 +1,35 @@
+{
+  "id": "litellm",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["litellm"],
+  "providerAuthEnvVars": {
+    "litellm": ["LITELLM_API_KEY"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "litellm",
+      "method": "api-key",
+      "choiceId": "litellm-api-key",
+      "choiceLabel": "LiteLLM API key",
+      "choiceHint": "Unified gateway for 100+ LLM providers",
+      "groupId": "litellm",
+      "groupLabel": "LiteLLM",
+      "groupHint": "Unified LLM gateway (100+ providers)",
+      "optionKey": "litellmApiKey",
+      "cliFlag": "--litellm-api-key",
+      "cliOption": "--litellm-api-key <key>",
+      "cliDescription": "LiteLLM API key"
+    }
+  ],
+  "contracts": {
+    "imageGenerationProviders": ["litellm"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/litellm/package.json

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

package/extensions/litellm/provider-catalog.ts

@@ -0,0 +1,10 @@
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import { buildLitellmModelDefinition, LITELLM_BASE_URL } from "./onboard.js";
+
+export function buildLitellmProvider(): ModelProviderConfig {
+  return {
+    baseUrl: LITELLM_BASE_URL,
+    api: "openai-completions",
+    models: [buildLitellmModelDefinition()],
+  };
+}

package/extensions/litellm/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/lmstudio/README.md

@@ -0,0 +1,3 @@
+# LM Studio Provider
+
+Bundled provider plugin for LM Studio discovery, auto-load, and setup.

package/extensions/lmstudio/api.ts

@@ -0,0 +1,36 @@
+export {
+  buildLmstudioAuthHeaders,
+  buildLmstudioModelName,
+  configureLmstudioNonInteractive,
+  discoverLmstudioProvider,
+  LMSTUDIO_DEFAULT_API_KEY_ENV_VAR,
+  LMSTUDIO_DEFAULT_BASE_URL,
+  LMSTUDIO_DEFAULT_EMBEDDING_MODEL,
+  LMSTUDIO_DEFAULT_INFERENCE_BASE_URL,
+  LMSTUDIO_DEFAULT_LOAD_CONTEXT_LENGTH,
+  LMSTUDIO_DEFAULT_MODEL_ID,
+  LMSTUDIO_DOCKER_HOST_BASE_URL,
+  LMSTUDIO_DOCKER_HOST_INFERENCE_BASE_URL,
+  LMSTUDIO_LOCAL_API_KEY_PLACEHOLDER,
+  LMSTUDIO_MODEL_PLACEHOLDER,
+  LMSTUDIO_PROVIDER_ID,
+  LMSTUDIO_PROVIDER_LABEL,
+  type LmstudioModelBase,
+  type LmstudioModelWire,
+  mapLmstudioWireEntry,
+  mapLmstudioWireModelsToConfig,
+  normalizeLmstudioConfiguredCatalogEntries,
+  normalizeLmstudioConfiguredCatalogEntry,
+  normalizeLmstudioProviderConfig,
+  prepareLmstudioDynamicModels,
+  promptAndConfigureLmstudioInteractive,
+  resolveLmstudioConfiguredApiKey,
+  resolveLmstudioInferenceBase,
+  resolveLmstudioProviderHeaders,
+  resolveLmstudioReasoningCapability,
+  resolveLmstudioReasoningCompat,
+  resolveLmstudioRequestContext,
+  resolveLmstudioRuntimeApiKey,
+  resolveLmstudioServerBase,
+  resolveLoadedContextWindow,
+} from "./src/api.js";

package/extensions/lmstudio/index.test.ts

@@ -0,0 +1,207 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
+import { capturePluginRegistration } from "openclaw/plugin-sdk/plugin-test-runtime";
+import { CUSTOM_LOCAL_AUTH_MARKER } from "openclaw/plugin-sdk/provider-auth";
+import type { ModelProviderConfig } from "openclaw/plugin-sdk/provider-model-shared";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+import { LMSTUDIO_LOCAL_API_KEY_PLACEHOLDER } from "./src/defaults.js";
+
+function registerProvider() {
+  const captured = capturePluginRegistration(plugin);
+  const provider = captured.providers[0];
+  expect(provider?.id).toBe("lmstudio");
+  return provider;
+}
+
+function createRemoteProviderConfig(overrides?: Partial<ModelProviderConfig>): ModelProviderConfig {
+  return {
+    api: "openai-completions",
+    baseUrl: "http://lmstudio.internal:1234/v1",
+    models: [
+      {
+        id: "qwen/qwen3.5-9b",
+        name: "Qwen 3.5 9B",
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 131072,
+        maxTokens: 8192,
+      },
+    ],
+    ...overrides,
+  };
+}
+
+describe("lmstudio plugin", () => {
+  it("canonicalizes base URLs during provider normalization", () => {
+    const provider = registerProvider();
+    const providerConfig = createRemoteProviderConfig({
+      baseUrl: "http://localhost:1234/api/v1/",
+    });
+
+    expect(
+      provider?.normalizeConfig?.({
+        provider: "lmstudio",
+        providerConfig,
+      }),
+    ).toEqual({
+      ...providerConfig,
+      baseUrl: "http://localhost:1234/v1",
+      request: { allowPrivateNetwork: true },
+    });
+  });
+
+  it("synthesizes placeholder auth for configured lmstudio models without API key auth", () => {
+    const provider = registerProvider();
+
+    expect(
+      provider?.resolveSyntheticAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig({
+          headers: {
+            "X-Proxy-Auth": "proxy-token",
+          },
+        }),
+      }),
+    ).toEqual({
+      apiKey: CUSTOM_LOCAL_AUTH_MARKER,
+      source: "models.providers.lmstudio (synthetic local key)",
+      mode: "api-key",
+    });
+  });
+
+  it("still synthesizes placeholder auth when explicit api-key auth has no key", () => {
+    const provider = registerProvider();
+
+    expect(
+      provider?.resolveSyntheticAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig({
+          auth: "api-key",
+        }),
+      }),
+    ).toEqual({
+      apiKey: CUSTOM_LOCAL_AUTH_MARKER,
+      source: "models.providers.lmstudio (synthetic local key)",
+      mode: "api-key",
+    });
+  });
+
+  it("does not synthesize placeholder auth when Authorization header is configured", () => {
+    const provider = registerProvider();
+
+    expect(
+      provider?.resolveSyntheticAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig({
+          headers: {
+            Authorization: "Bearer proxy-token",
+          },
+        }),
+      }),
+    ).toBeUndefined();
+  });
+
+  it("defers stored lmstudio-local profile auth so real credentials can win", () => {
+    const provider = registerProvider();
+
+    expect(
+      provider?.shouldDeferSyntheticProfileAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig(),
+        resolvedApiKey: LMSTUDIO_LOCAL_API_KEY_PLACEHOLDER,
+      }),
+    ).toBe(true);
+
+    expect(
+      provider?.shouldDeferSyntheticProfileAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig(),
+        resolvedApiKey: CUSTOM_LOCAL_AUTH_MARKER,
+      }),
+    ).toBe(true);
+
+    expect(
+      provider?.shouldDeferSyntheticProfileAuth?.({
+        provider: "lmstudio",
+        config: {},
+        providerConfig: createRemoteProviderConfig(),
+        resolvedApiKey: "lmstudio-real-key",
+      }),
+    ).toBe(false);
+  });
+
+  it("augments the catalog with configured lmstudio models", () => {
+    const provider = registerProvider();
+    const config = {
+      models: {
+        providers: {
+          lmstudio: {
+            models: [
+              {
+                id: "qwen3-8b-instruct",
+                name: "Qwen 3 8B Instruct",
+                contextWindow: 32768,
+                contextTokens: 8192,
+                reasoning: true,
+                input: ["text", "image"],
+                compat: {
+                  supportsReasoningEffort: true,
+                  supportedReasoningEfforts: ["off", "on"],
+                  reasoningEffortMap: { off: "off", high: "on" },
+                },
+              },
+              {
+                id: "phi-4",
+              },
+              {
+                id: " ",
+                name: "ignored",
+              },
+            ],
+          },
+        },
+      },
+    } as unknown as OpenClawConfig;
+
+    expect(
+      provider?.augmentModelCatalog?.({
+        config,
+        agentDir: "/tmp/openclaw",
+        env: {},
+        entries: [],
+      }),
+    ).toEqual([
+      {
+        provider: "lmstudio",
+        id: "qwen3-8b-instruct",
+        name: "Qwen 3 8B Instruct",
+        compat: {
+          supportsUsageInStreaming: true,
+          supportsReasoningEffort: true,
+          supportedReasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh"],
+          reasoningEffortMap: { off: "none", none: "none", adaptive: "xhigh", max: "xhigh" },
+        },
+        contextWindow: 32768,
+        contextTokens: 8192,
+        reasoning: true,
+        input: ["text", "image"],
+      },
+      {
+        provider: "lmstudio",
+        id: "phi-4",
+        name: "phi-4",
+        compat: { supportsUsageInStreaming: true },
+        contextWindow: undefined,
+        contextTokens: undefined,
+        reasoning: undefined,
+        input: undefined,
+      },
+    ]);
+  });
+});

package/extensions/lmstudio/index.ts

@@ -0,0 +1,137 @@
+import {
+  definePluginEntry,
+  OpenClawConfig,
+  type OpenClawPluginApi,
+  type ProviderAuthContext,
+  type ProviderAuthMethodNonInteractiveContext,
+  type ProviderAuthResult,
+  type ProviderRuntimeModel,
+} from "openclaw/plugin-sdk/plugin-entry";
+import { CUSTOM_LOCAL_AUTH_MARKER } from "openclaw/plugin-sdk/provider-auth";
+import { lmstudioMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";
+import {
+  LMSTUDIO_DEFAULT_API_KEY_ENV_VAR,
+  LMSTUDIO_LOCAL_API_KEY_PLACEHOLDER,
+  LMSTUDIO_PROVIDER_LABEL,
+} from "./src/defaults.js";
+import {
+  normalizeLmstudioConfiguredCatalogEntries,
+  normalizeLmstudioProviderConfig,
+} from "./src/models.js";
+import { shouldUseLmstudioSyntheticAuth } from "./src/provider-auth.js";
+import { wrapLmstudioInferencePreload } from "./src/stream.js";
+
+const PROVIDER_ID = "lmstudio";
+// Intentional: dynamic models are cached per LM Studio endpoint (`baseUrl`) only.
+const cachedDynamicModels = new Map<string, ProviderRuntimeModel[]>();
+
+function resolveLmstudioAugmentedCatalogEntries(config: OpenClawConfig | undefined) {
+  if (!config) {
+    return [];
+  }
+  return normalizeLmstudioConfiguredCatalogEntries(config.models?.providers?.lmstudio?.models).map(
+    (entry) => ({
+      provider: PROVIDER_ID,
+      id: entry.id,
+      name: entry.name ?? entry.id,
+      compat: { ...entry.compat, supportsUsageInStreaming: true },
+      contextWindow: entry.contextWindow,
+      contextTokens: entry.contextTokens,
+      reasoning: entry.reasoning,
+      input: entry.input,
+    }),
+  );
+}
+
+/** Lazily loads setup helpers so provider wiring stays lightweight at startup. */
+async function loadProviderSetup() {
+  return await import("./api.js");
+}
+
+export default definePluginEntry({
+  id: PROVIDER_ID,
+  name: "LM Studio Provider",
+  description: "Bundled LM Studio provider plugin",
+  register(api: OpenClawPluginApi) {
+    api.registerMemoryEmbeddingProvider(lmstudioMemoryEmbeddingProviderAdapter);
+    api.registerProvider({
+      id: PROVIDER_ID,
+      label: "LM Studio",
+      docsPath: "/providers/lmstudio",
+      envVars: [LMSTUDIO_DEFAULT_API_KEY_ENV_VAR],
+      auth: [
+        {
+          id: "custom",
+          label: LMSTUDIO_PROVIDER_LABEL,
+          hint: "Local/self-hosted LM Studio server",
+          kind: "custom",
+          run: async (ctx: ProviderAuthContext): Promise<ProviderAuthResult> => {
+            const providerSetup = await loadProviderSetup();
+            return await providerSetup.promptAndConfigureLmstudioInteractive({
+              config: ctx.config,
+              agentDir: ctx.agentDir,
+              prompter: ctx.prompter,
+              secretInputMode: ctx.secretInputMode,
+              allowSecretRefPrompt: ctx.allowSecretRefPrompt,
+            });
+          },
+          runNonInteractive: async (ctx: ProviderAuthMethodNonInteractiveContext) => {
+            const providerSetup = await loadProviderSetup();
+            return await providerSetup.configureLmstudioNonInteractive(ctx);
+          },
+        },
+      ],
+      catalog: {
+        // Run after early providers so local LM Studio detection does not dominate resolution.
+        order: "late",
+        run: async (ctx) => {
+          const providerSetup = await loadProviderSetup();
+          return await providerSetup.discoverLmstudioProvider(ctx);
+        },
+      },
+      resolveSyntheticAuth: ({ providerConfig }) => {
+        if (!shouldUseLmstudioSyntheticAuth(providerConfig)) {
+          return undefined;
+        }
+        return {
+          apiKey: CUSTOM_LOCAL_AUTH_MARKER,
+          source: "models.providers.lmstudio (synthetic local key)",
+          mode: "api-key" as const,
+        };
+      },
+      shouldDeferSyntheticProfileAuth: ({ resolvedApiKey }) =>
+        resolvedApiKey?.trim() === LMSTUDIO_LOCAL_API_KEY_PLACEHOLDER ||
+        resolvedApiKey?.trim() === CUSTOM_LOCAL_AUTH_MARKER,
+      normalizeConfig: ({ providerConfig }) => normalizeLmstudioProviderConfig(providerConfig),
+      prepareDynamicModel: async (ctx) => {
+        const providerSetup = await loadProviderSetup();
+        cachedDynamicModels.set(
+          ctx.providerConfig?.baseUrl ?? "",
+          await providerSetup.prepareLmstudioDynamicModels(ctx),
+        );
+      },
+      resolveDynamicModel: (ctx) =>
+        cachedDynamicModels
+          .get(ctx.providerConfig?.baseUrl ?? "")
+          ?.find((model) => model.id === ctx.modelId),
+      augmentModelCatalog: (ctx) => resolveLmstudioAugmentedCatalogEntries(ctx.config),
+      wrapStreamFn: wrapLmstudioInferencePreload,
+      wizard: {
+        setup: {
+          choiceId: PROVIDER_ID,
+          choiceLabel: "LM Studio",
+          choiceHint: "Local/self-hosted LM Studio server",
+          groupId: PROVIDER_ID,
+          groupLabel: "LM Studio",
+          groupHint: "Self-hosted open-weight models",
+          methodId: "custom",
+        },
+        modelPicker: {
+          label: "LM Studio (custom)",
+          hint: "Detect models from LM Studio /api/v1/models",
+          methodId: "custom",
+        },
+      },
+    });
+  },
+});

package/extensions/lmstudio/memory-embedding-adapter.ts

@@ -0,0 +1,36 @@
+import {
+  sanitizeEmbeddingCacheHeaders,
+  type MemoryEmbeddingProviderAdapter,
+} from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
+import {
+  createLmstudioEmbeddingProvider,
+  DEFAULT_LMSTUDIO_EMBEDDING_MODEL,
+} from "./src/embedding-provider.js";
+
+export const lmstudioMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter = {
+  id: "lmstudio",
+  defaultModel: DEFAULT_LMSTUDIO_EMBEDDING_MODEL,
+  transport: "remote",
+  authProviderId: "lmstudio",
+  allowExplicitWhenConfiguredAuto: true,
+  create: async (options) => {
+    const { provider, client } = await createLmstudioEmbeddingProvider({
+      ...options,
+      provider: "lmstudio",
+      fallback: "none",
+    });
+    return {
+      provider,
+      runtime: {
+        id: "lmstudio",
+        inlineBatchTimeoutMs: 10 * 60_000,
+        cacheKeyData: {
+          provider: "lmstudio",
+          baseUrl: client.baseUrl,
+          model: client.model,
+          headers: sanitizeEmbeddingCacheHeaders(client.headers, ["authorization"]),
+        },
+      },
+    };
+  },
+};

package/extensions/lmstudio/openclaw.plugin.json

@@ -0,0 +1,53 @@
+{
+  "id": "lmstudio",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["lmstudio"],
+  "providerRequest": {
+    "providers": {
+      "lmstudio": {
+        "family": "lmstudio",
+        "openAICompletions": {
+          "supportsStreamingUsage": true
+        }
+      }
+    }
+  },
+  "modelPricing": {
+    "providers": {
+      "lmstudio": {
+        "external": false
+      }
+    }
+  },
+  "nonSecretAuthMarkers": ["lmstudio-local"],
+  "providerAuthEnvVars": {
+    "lmstudio": ["LM_API_TOKEN"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "lmstudio",
+      "method": "custom",
+      "choiceId": "lmstudio",
+      "choiceLabel": "LM Studio",
+      "choiceHint": "Local/self-hosted LM Studio server",
+      "optionKey": "lmstudioApiKey",
+      "cliFlag": "--lmstudio-api-key",
+      "cliOption": "--lmstudio-api-key <key>",
+      "cliDescription": "LM Studio API key",
+      "groupId": "lmstudio",
+      "groupLabel": "LM Studio",
+      "groupHint": "Self-hosted open-weight models"
+    }
+  ],
+  "contracts": {
+    "memoryEmbeddingProviders": ["lmstudio"]
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/lmstudio/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@openclaw/lmstudio-provider",
+  "version": "2026.5.21",
+  "private": true,
+  "description": "OpenClaw LM Studio provider plugin",
+  "type": "module",
+  "dependencies": {
+    "@earendil-works/pi-ai": "0.75.4"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

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

@@ -0,0 +1,6 @@
+import { describePluginRegistrationContract } from "openclaw/plugin-sdk/plugin-test-contracts";
+
+describePluginRegistrationContract({
+  pluginId: "lmstudio",
+  providerIds: ["lmstudio"],
+});