@full-self-developing/fsd 1.0.0

package/extensions/opencode/openclaw.plugin.json

@@ -0,0 +1,55 @@
+{
+  "id": "opencode",
+  "activation": {
+    "onStartup": false
+  },
+  "enabledByDefault": true,
+  "providers": ["opencode"],
+  "providerEndpoints": [
+    {
+      "endpointClass": "opencode-native",
+      "hostSuffixes": ["opencode.ai"]
+    }
+  ],
+  "providerRequest": {
+    "providers": {
+      "opencode": {
+        "family": "opencode"
+      }
+    }
+  },
+  "providerAuthEnvVars": {
+    "opencode": ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"]
+  },
+  "providerAuthChoices": [
+    {
+      "provider": "opencode",
+      "method": "api-key",
+      "choiceId": "opencode-zen",
+      "choiceLabel": "OpenCode Zen catalog",
+      "groupId": "opencode",
+      "groupLabel": "OpenCode",
+      "groupHint": "Shared API key for Zen + Go catalogs",
+      "optionKey": "opencodeZenApiKey",
+      "cliFlag": "--opencode-zen-api-key",
+      "cliOption": "--opencode-zen-api-key <key>",
+      "cliDescription": "OpenCode API key (Zen catalog)"
+    }
+  ],
+  "contracts": {
+    "mediaUnderstandingProviders": ["opencode"]
+  },
+  "mediaUnderstandingProviderMetadata": {
+    "opencode": {
+      "capabilities": ["image"],
+      "defaultModels": {
+        "image": "gpt-5-nano"
+      }
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/opencode/package.json

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

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

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

package/extensions/opencode/provider-policy-api.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { resolveThinkingProfile } from "./provider-policy-api.js";
+
+describe("opencode provider policy public artifact", () => {
+  it("exposes Claude Opus 4.7 thinking levels without loading the full provider plugin", () => {
+    expect(
+      resolveThinkingProfile({
+        provider: "opencode",
+        modelId: "claude-opus-4-7",
+      }),
+    ).toEqual({
+      levels: [
+        { id: "off" },
+        { id: "minimal" },
+        { id: "low" },
+        { id: "medium" },
+        { id: "high" },
+        { id: "xhigh" },
+        { id: "adaptive" },
+        { id: "max" },
+      ],
+      defaultLevel: "off",
+    });
+  });
+
+  it("keeps adaptive-only Claude profiles aligned with Anthropic", () => {
+    const profile = resolveThinkingProfile({
+      provider: "opencode",
+      modelId: "claude-opus-4-6",
+    });
+
+    expect(profile).toEqual({
+      levels: [
+        { id: "off" },
+        { id: "minimal" },
+        { id: "low" },
+        { id: "medium" },
+        { id: "high" },
+        { id: "adaptive" },
+      ],
+      defaultLevel: "adaptive",
+    });
+  });
+});

package/extensions/opencode/provider-policy-api.ts

@@ -0,0 +1,5 @@
+import { resolveClaudeThinkingProfile } from "openclaw/plugin-sdk/provider-model-shared";
+
+export function resolveThinkingProfile(params: { provider?: string; modelId: string }) {
+  return resolveClaudeThinkingProfile(params.modelId);
+}

package/extensions/opencode/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/opencode-go/api.ts

@@ -0,0 +1,27 @@
+import {
+  applyAgentDefaultModelPrimary,
+  resolveAgentModelPrimaryValue,
+} from "openclaw/plugin-sdk/provider-onboard";
+import { OPENCODE_GO_DEFAULT_MODEL_REF } from "./onboard.js";
+
+export {
+  applyOpencodeGoConfig,
+  applyOpencodeGoProviderConfig,
+  OPENCODE_GO_DEFAULT_MODEL_REF,
+} from "./onboard.js";
+
+export function applyOpencodeGoModelDefault(
+  cfg: import("openclaw/plugin-sdk/provider-onboard").OpenClawConfig,
+): {
+  next: import("openclaw/plugin-sdk/provider-onboard").OpenClawConfig;
+  changed: boolean;
+} {
+  const current = resolveAgentModelPrimaryValue(cfg.agents?.defaults?.model);
+  if (current === OPENCODE_GO_DEFAULT_MODEL_REF) {
+    return { next: cfg, changed: false };
+  }
+  return {
+    next: applyAgentDefaultModelPrimary(cfg, OPENCODE_GO_DEFAULT_MODEL_REF),
+    changed: true,
+  };
+}

package/extensions/opencode-go/index.test.ts

@@ -0,0 +1,305 @@
+import { getModels } from "@earendil-works/pi-ai";
+import {
+  registerProviderPlugin,
+  registerSingleProviderPlugin,
+} from "openclaw/plugin-sdk/plugin-test-runtime";
+import { expectPassthroughReplayPolicy } from "openclaw/plugin-sdk/provider-test-contracts";
+import { describe, expect, it } from "vitest";
+import plugin from "./index.js";
+
+function requireRecord(value: unknown, label: string): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`expected ${label} to be a record`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function requireMapEntry<T>(map: Map<string, T>, id: string): T {
+  const entry = map.get(id);
+  if (!entry) {
+    throw new Error(`expected model ${id}`);
+  }
+  return entry;
+}
+
+function requireCatalogEntry(entries: readonly unknown[] | null | undefined, id: string) {
+  if (!entries) {
+    throw new Error("expected supplemental catalog entries");
+  }
+  const entry = entries.find((candidate) => requireRecord(candidate, "catalog entry").id === id);
+  if (!entry) {
+    throw new Error(`expected supplemental catalog entry ${id}`);
+  }
+  return requireRecord(entry, `supplemental catalog entry ${id}`);
+}
+
+describe("opencode-go provider plugin", () => {
+  it("registers image media understanding through the OpenCode Go plugin", async () => {
+    const { mediaProviders } = await registerProviderPlugin({
+      plugin,
+      id: "opencode-go",
+      name: "OpenCode Go Provider",
+    });
+
+    const mediaProvider = mediaProviders.find((provider) => provider.id === "opencode-go");
+    if (!mediaProvider) {
+      throw new Error("Expected opencode-go media provider");
+    }
+    expect(mediaProvider.capabilities).toEqual(["image"]);
+    expect(mediaProvider.defaultModels).toEqual({ image: "kimi-k2.6" });
+    expect(typeof mediaProvider.describeImage).toBe("function");
+    expect(typeof mediaProvider.describeImages).toBe("function");
+  });
+
+  it("owns passthrough-gemini replay policy for Gemini-backed models", async () => {
+    await expectPassthroughReplayPolicy({
+      plugin,
+      providerId: "opencode-go",
+      modelId: "gemini-2.5-pro",
+      sanitizeThoughtSignatures: true,
+    });
+  });
+
+  it("keeps non-Gemini replay policy minimal on passthrough routes", async () => {
+    await expectPassthroughReplayPolicy({
+      plugin,
+      providerId: "opencode-go",
+      modelId: "qwen3-coder",
+    });
+  });
+
+  it("keeps OpenCode Go catalog coverage aligned with upstream", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+    expect(provider.catalog).toBeUndefined();
+
+    const models = new Map(getModels("opencode-go").map((model) => [model.id, model]));
+    expect([...models.keys()]).toEqual([
+      "deepseek-v4-flash",
+      "deepseek-v4-pro",
+      "glm-5",
+      "glm-5.1",
+      "kimi-k2.5",
+      "kimi-k2.6",
+      "mimo-v2.5",
+      "mimo-v2.5-pro",
+      "minimax-m2.5",
+      "minimax-m2.7",
+      "qwen3.5-plus",
+      "qwen3.6-plus",
+    ]);
+    const supplemental = await provider.augmentModelCatalog?.({
+      entries: [...models.values()].map((model) => ({
+        provider: model.provider,
+        id: model.id,
+        name: model.name,
+      })),
+    } as never);
+    const deepSeekPro = requireCatalogEntry(supplemental, "deepseek-v4-pro");
+    expect(deepSeekPro.provider).toBe("opencode-go");
+    expect(deepSeekPro.name).toBe("DeepSeek V4 Pro");
+    const deepSeekFlash = requireCatalogEntry(supplemental, "deepseek-v4-flash");
+    expect(deepSeekFlash.provider).toBe("opencode-go");
+    expect(deepSeekFlash.name).toBe("DeepSeek V4 Flash");
+
+    const kimi = requireMapEntry(models, "kimi-k2.6");
+    expect(kimi.api).toBe("openai-completions");
+    expect(kimi.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+    expect(kimi.input).toEqual(["text", "image"]);
+    expect(kimi.reasoning).toBe(true);
+    expect(kimi.contextWindow).toBe(262_144);
+    expect(kimi.maxTokens).toBe(65_536);
+
+    const minimax = requireMapEntry(models, "minimax-m2.7");
+    expect(minimax.api).toBe("openai-completions");
+    expect(minimax.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+    expect(minimax.reasoning).toBe(true);
+    expect(minimax.contextWindow).toBe(204_800);
+    expect(minimax.maxTokens).toBe(131_072);
+
+    const mimoPro = requireMapEntry(models, "mimo-v2.5-pro");
+    expect(mimoPro.api).toBe("openai-completions");
+    expect(mimoPro.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+    expect(mimoPro.input).toEqual(["text"]);
+    expect(mimoPro.reasoning).toBe(true);
+    expect(mimoPro.contextWindow).toBe(1_048_576);
+    expect(mimoPro.maxTokens).toBe(128_000);
+
+    const mimo = requireMapEntry(models, "mimo-v2.5");
+    expect(mimo.input).toEqual(["text", "image"]);
+    expect(mimo.reasoning).toBe(true);
+    expect(mimo.contextWindow).toBe(1_000_000);
+    expect(mimo.maxTokens).toBe(128_000);
+
+    const dynamicModel = requireRecord(
+      provider.resolveDynamicModel?.({
+        modelId: "deepseek-v4-pro",
+      } as never),
+      "dynamic model",
+    );
+    expect(dynamicModel.id).toBe("deepseek-v4-pro");
+    expect(dynamicModel.api).toBe("openai-completions");
+    expect(dynamicModel.provider).toBe("opencode-go");
+    expect(dynamicModel.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+    expect(dynamicModel.reasoning).toBe(true);
+    expect(dynamicModel.contextWindow).toBe(1_000_000);
+    expect(dynamicModel.maxTokens).toBe(384_000);
+    const compat = requireRecord(dynamicModel.compat, "dynamic model compat");
+    expect(compat.supportsUsageInStreaming).toBe(true);
+    expect(compat.supportsReasoningEffort).toBe(true);
+    expect(compat.maxTokensField).toBe("max_tokens");
+  });
+
+  it("disables invalid DeepSeek V4 reasoning_effort off payloads on OpenCode Go", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+    const capturedPayloads: Record<string, unknown>[] = [];
+    const baseStreamFn = (_model: unknown, _context: unknown, options: unknown) => {
+      const payload = {
+        model: "deepseek-v4-flash",
+        reasoning_effort: "off",
+        reasoning: "off",
+      };
+      (options as { onPayload?: (payload: Record<string, unknown>) => void })?.onPayload?.(payload);
+      capturedPayloads.push(payload);
+      return {} as never;
+    };
+
+    const streamFn = provider.wrapStreamFn?.({
+      streamFn: baseStreamFn as never,
+      providerId: "opencode-go",
+      modelId: "deepseek-v4-flash",
+      thinkingLevel: "off",
+    } as never);
+
+    expect(streamFn).toBeTypeOf("function");
+    await streamFn?.(
+      { provider: "opencode-go", id: "deepseek-v4-flash" } as never,
+      {} as never,
+      {},
+    );
+
+    expect(capturedPayloads).toEqual([
+      {
+        model: "deepseek-v4-flash",
+        thinking: { type: "disabled" },
+      },
+    ]);
+  });
+
+  it("strips unsupported Kimi reasoning payloads on OpenCode Go", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+    const capturedPayloads: Record<string, unknown>[] = [];
+    const baseStreamFn = (_model: unknown, _context: unknown, options: unknown) => {
+      const payload = {
+        model: "kimi-k2.6",
+        reasoning_effort: "high",
+        reasoning: { effort: "high" },
+        reasoningEffort: "high",
+      };
+      (options as { onPayload?: (payload: Record<string, unknown>) => void })?.onPayload?.(payload);
+      capturedPayloads.push(payload);
+      return {} as never;
+    };
+
+    const streamFn = provider.wrapStreamFn?.({
+      streamFn: baseStreamFn as never,
+      providerId: "opencode-go",
+      modelId: "kimi-k2.6",
+      thinkingLevel: "high",
+    } as never);
+
+    expect(streamFn).toBeTypeOf("function");
+    await streamFn?.(
+      { provider: "opencode-go", id: "kimi-k2.6", api: "openai-completions" } as never,
+      {} as never,
+      {},
+    );
+
+    expect(capturedPayloads).toEqual([
+      {
+        model: "kimi-k2.6",
+      },
+    ]);
+  });
+
+  it("canonicalizes stale OpenCode Go base URLs", async () => {
+    const provider = await registerSingleProviderPlugin(plugin);
+
+    const normalizedConfig = requireRecord(
+      provider.normalizeConfig?.({
+        provider: "opencode-go",
+        providerConfig: {
+          api: "openai-completions",
+          baseUrl: "https://opencode.ai/go/v1/",
+          models: [],
+        },
+      } as never),
+      "normalized config",
+    );
+    expect(normalizedConfig.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+
+    const normalizedModel = requireRecord(
+      provider.normalizeResolvedModel?.({
+        provider: "opencode-go",
+        model: {
+          provider: "opencode-go",
+          id: "kimi-k2.5",
+          name: "Kimi K2.5",
+          api: "openai-completions",
+          baseUrl: "https://opencode.ai/go/v1",
+          reasoning: true,
+          input: ["text"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 262_144,
+          maxTokens: 65_536,
+        },
+      } as never),
+      "normalized model",
+    );
+    expect(normalizedModel.baseUrl).toBe("https://opencode.ai/zen/go/v1");
+
+    const normalizedKimi = requireRecord(
+      provider.normalizeResolvedModel?.({
+        provider: "opencode-go",
+        model: {
+          provider: "opencode-go",
+          id: "kimi-k2.6",
+          name: "Kimi K2.6",
+          api: "openai-completions",
+          baseUrl: "https://opencode.ai/zen/go/v1",
+          reasoning: true,
+          input: ["text", "image"],
+          cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          contextWindow: 262_144,
+          maxTokens: 65_536,
+        },
+      } as never),
+      "normalized Kimi model",
+    );
+    expect(normalizedKimi.reasoning).toBe(false);
+    expect(requireRecord(normalizedKimi.compat, "normalized Kimi compat")).toMatchObject({
+      supportsReasoningEffort: false,
+    });
+
+    expect(
+      provider.normalizeTransport?.({
+        provider: "opencode-go",
+        api: "openai-completions",
+        baseUrl: "https://opencode.ai/go/v1",
+      } as never),
+    ).toEqual({
+      api: "openai-completions",
+      baseUrl: "https://opencode.ai/zen/go/v1",
+    });
+
+    expect(
+      provider.normalizeTransport?.({
+        provider: "opencode-go",
+        api: "anthropic-messages",
+        baseUrl: "https://opencode.ai/go",
+      } as never),
+    ).toEqual({
+      api: "anthropic-messages",
+      baseUrl: "https://opencode.ai/zen/go",
+    });
+  });
+});

package/extensions/opencode-go/index.ts

@@ -0,0 +1,101 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth-api-key";
+import { PASSTHROUGH_GEMINI_REPLAY_HOOKS } from "openclaw/plugin-sdk/provider-model-shared";
+import { applyOpencodeGoConfig, OPENCODE_GO_DEFAULT_MODEL_REF } from "./api.js";
+import { opencodeGoMediaUnderstandingProvider } from "./media-understanding-provider.js";
+import {
+  listOpencodeGoSupplementalModelCatalogEntries,
+  normalizeOpencodeGoBaseUrl,
+  normalizeOpencodeGoResolvedModel,
+  resolveOpencodeGoSupplementalModel,
+} from "./provider-catalog.js";
+import { createOpencodeGoWrapper } from "./stream.js";
+
+const PROVIDER_ID = "opencode-go";
+const OPENCODE_SHARED_PROFILE_IDS = ["opencode:default", "opencode-go:default"] as const;
+const OPENCODE_SHARED_HINT = "Shared API key for Zen + Go catalogs";
+const OPENCODE_SHARED_WIZARD_GROUP = {
+  groupId: "opencode",
+  groupLabel: "OpenCode",
+  groupHint: OPENCODE_SHARED_HINT,
+} as const;
+
+export default definePluginEntry({
+  id: PROVIDER_ID,
+  name: "OpenCode Go Provider",
+  description: "Bundled OpenCode Go provider plugin",
+  register(api) {
+    api.registerProvider({
+      id: PROVIDER_ID,
+      label: "OpenCode Go",
+      docsPath: "/providers/models",
+      envVars: ["OPENCODE_API_KEY", "OPENCODE_ZEN_API_KEY"],
+      auth: [
+        createProviderApiKeyAuthMethod({
+          providerId: PROVIDER_ID,
+          methodId: "api-key",
+          label: "OpenCode Go catalog",
+          hint: OPENCODE_SHARED_HINT,
+          optionKey: "opencodeGoApiKey",
+          flagName: "--opencode-go-api-key",
+          envVar: "OPENCODE_API_KEY",
+          promptMessage: "Enter OpenCode API key",
+          profileIds: [...OPENCODE_SHARED_PROFILE_IDS],
+          defaultModel: OPENCODE_GO_DEFAULT_MODEL_REF,
+          applyConfig: (cfg) => applyOpencodeGoConfig(cfg),
+          expectedProviders: ["opencode", "opencode-go"],
+          noteMessage: [
+            "OpenCode uses one API key across the Zen and Go catalogs.",
+            "Go focuses on Kimi, GLM, and MiniMax coding models.",
+            "Get your API key at: https://opencode.ai/auth",
+          ].join("\n"),
+          noteTitle: "OpenCode",
+          wizard: {
+            choiceId: "opencode-go",
+            choiceLabel: "OpenCode Go catalog",
+            ...OPENCODE_SHARED_WIZARD_GROUP,
+          },
+        }),
+      ],
+      normalizeConfig: ({ providerConfig }) => {
+        const normalizedBaseUrl = normalizeOpencodeGoBaseUrl({
+          api: providerConfig.api,
+          baseUrl: providerConfig.baseUrl,
+        });
+        return normalizedBaseUrl && normalizedBaseUrl !== providerConfig.baseUrl
+          ? { ...providerConfig, baseUrl: normalizedBaseUrl }
+          : undefined;
+      },
+      normalizeResolvedModel: ({ model }) => {
+        const normalizedBaseUrl = normalizeOpencodeGoBaseUrl({
+          api: model.api,
+          baseUrl: model.baseUrl,
+        });
+        const baseUrlNormalized =
+          normalizedBaseUrl && normalizedBaseUrl !== model.baseUrl
+            ? { ...model, baseUrl: normalizedBaseUrl }
+            : model;
+        const modelNormalized = normalizeOpencodeGoResolvedModel(baseUrlNormalized);
+        if (modelNormalized) {
+          return modelNormalized;
+        }
+        return baseUrlNormalized !== model ? baseUrlNormalized : undefined;
+      },
+      normalizeTransport: ({ api, baseUrl }) => {
+        const normalizedBaseUrl = normalizeOpencodeGoBaseUrl({ api, baseUrl });
+        return normalizedBaseUrl && normalizedBaseUrl !== baseUrl
+          ? {
+              api,
+              baseUrl: normalizedBaseUrl,
+            }
+          : undefined;
+      },
+      resolveDynamicModel: ({ modelId }) => resolveOpencodeGoSupplementalModel(modelId),
+      augmentModelCatalog: () => listOpencodeGoSupplementalModelCatalogEntries(),
+      ...PASSTHROUGH_GEMINI_REPLAY_HOOKS,
+      wrapStreamFn: (ctx) => createOpencodeGoWrapper(ctx.streamFn, ctx.thinkingLevel),
+      isModernModelRef: () => true,
+    });
+    api.registerMediaUnderstandingProvider(opencodeGoMediaUnderstandingProvider);
+  },
+});

package/extensions/opencode-go/media-understanding-provider.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { opencodeGoMediaUnderstandingProvider } from "./media-understanding-provider.js";
+
+describe("opencode-go media understanding provider", () => {
+  it("declares image understanding support", () => {
+    expect(opencodeGoMediaUnderstandingProvider.id).toBe("opencode-go");
+    expect(opencodeGoMediaUnderstandingProvider.capabilities).toEqual(["image"]);
+    expect(opencodeGoMediaUnderstandingProvider.defaultModels).toEqual({ image: "kimi-k2.6" });
+    expect(typeof opencodeGoMediaUnderstandingProvider.describeImage).toBe("function");
+    expect(typeof opencodeGoMediaUnderstandingProvider.describeImages).toBe("function");
+  });
+});

package/extensions/opencode-go/media-understanding-provider.ts

@@ -0,0 +1,15 @@
+import {
+  describeImageWithModel,
+  describeImagesWithModel,
+  type MediaUnderstandingProvider,
+} from "openclaw/plugin-sdk/media-understanding";
+
+export const opencodeGoMediaUnderstandingProvider: MediaUnderstandingProvider = {
+  id: "opencode-go",
+  capabilities: ["image"],
+  defaultModels: {
+    image: "kimi-k2.6",
+  },
+  describeImage: describeImageWithModel,
+  describeImages: describeImagesWithModel,
+};

package/extensions/opencode-go/onboard.test.ts

@@ -0,0 +1,28 @@
+import { expectProviderOnboardPrimaryAndFallbacks } from "openclaw/plugin-sdk/provider-test-contracts";
+import { describe, expect, it } from "vitest";
+import { applyOpencodeGoConfig, applyOpencodeGoProviderConfig } from "./onboard.js";
+
+const MODEL_REF = "opencode-go/kimi-k2.6";
+
+describe("opencode-go onboard", () => {
+  it("leaves model aliases to the pi catalog", () => {
+    const cfg = {
+      agents: {
+        defaults: {
+          models: {
+            [MODEL_REF]: { alias: "Kimi" },
+          },
+        },
+      },
+    };
+
+    expect(applyOpencodeGoProviderConfig(cfg)).toBe(cfg);
+  });
+
+  it("sets primary model and preserves existing model fallbacks", () => {
+    expectProviderOnboardPrimaryAndFallbacks({
+      applyConfig: applyOpencodeGoConfig,
+      modelRef: MODEL_REF,
+    });
+  });
+});

package/extensions/opencode-go/onboard.ts

@@ -0,0 +1,17 @@
+import {
+  applyAgentDefaultModelPrimary,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/provider-onboard";
+
+export const OPENCODE_GO_DEFAULT_MODEL_REF = "opencode-go/kimi-k2.6";
+
+export function applyOpencodeGoProviderConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return cfg;
+}
+
+export function applyOpencodeGoConfig(cfg: OpenClawConfig): OpenClawConfig {
+  return applyAgentDefaultModelPrimary(
+    applyOpencodeGoProviderConfig(cfg),
+    OPENCODE_GO_DEFAULT_MODEL_REF,
+  );
+}