import plugin from "./index.js";

import manifest from "./openclaw.plugin.json" with { type: "json" };

import { buildOpencodeGoLiveProviderConfig } from "./provider-catalog.js";

import opencodeGoProviderDiscovery from "./provider-discovery.js";

function requireRecord(value: unknown, label: string): Record<string, unknown> {

if (value === null || typeof value !== "object" || Array.isArray(value)) {

});

it("loads OpenCode Go model discovery through the provider runtime", () => {

expect(manifest.providerCatalogEntry).toBe("./provider-discovery.ts");

expect(manifest.modelCatalog.discovery["opencode-go"]).toBe("runtime");

});

it("exposes the complete offline catalog through provider discovery", async () => {

const result = await opencodeGoProviderDiscovery.staticCatalog?.run({} as never);

if (!result || !("provider" in result)) {

throw new Error("expected OpenCode Go static provider");

}

const deepSeekPro = result.provider.models.find((model) => model.id === "deepseek-v4-pro");

expect(result.provider.models).toHaveLength(18);

expect(deepSeekPro).toMatchObject({

provider: "opencode-go",

contextWindow: 1_000_000,

maxTokens: 384_000,

});

});

it("skips live OpenCode Go catalog discovery when no shared key is configured", async () => {

const provider = await registerSingleProviderPlugin(plugin);

"activation": {

"onStartup": false

},

"providerCatalogEntry": "./provider-discovery.ts",

"enabledByDefault": true,

"providers": ["opencode-go"],

"providerEndpoints": [

// Opencode Go provider module exposes offline catalog metadata to core discovery.

import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-model-shared";

import { buildStaticOpencodeGoProviderConfig } from "./provider-catalog.js";

const opencodeGoProviderDiscovery: ProviderPlugin = {

id: "opencode-go",

label: "OpenCode Go",

docsPath: "/providers/models",

auth: [],

staticCatalog: {

order: "simple",

run: async () => ({

provider: buildStaticOpencodeGoProviderConfig(),

}),

},

};

export default opencodeGoProviderDiscovery;

import { afterEach, describe, expect, it } from "vitest";

import { resolveMemoryFlushContextWindowTokens } from "../auto-reply/reply/memory-flush.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { refreshContextWindowCache, resetContextWindowCacheForTest } from "./context.js";

describe("OpenCode Go context metadata", () => {

afterEach(() => {

resetContextWindowCacheForTest();

});

it("warms the provider-owned context window without writing model config", async () => {

const cfg: OpenClawConfig = {};

await refreshContextWindowCache(cfg);

expect(

resolveMemoryFlushContextWindowTokens({

cfg,

provider: "opencode-go",

modelId: "deepseek-v4-pro",

}),

).toBe(1_000_000);

expect(cfg.models).toBeUndefined();

});

});