nanocoai/nanoclaw / .claude/skills/add-opencode
add-opencode
VerifiedUse OpenCode as an agent provider. OpenRouter, OpenAI, Google, DeepSeek, etc. via OpenCode config — not the Anthropic Agent SDK. Per group via `ncl groups config update --provider opencode`; host passes OPENCODE_* and XDG mount when spawning containers.
payload/container/agent-runner/src/providers/opencode.config.test.ts
View on GitHubimport { describe, it, expect, afterEach } from 'bun:test';
import { buildOpenCodeConfig, resolveOpenCodePromptModel } from './opencode-config.js';
const ENV_KEYS = [
'OPENCODE_PROVIDER',
'OPENCODE_MODEL',
'OPENCODE_SMALL_MODEL',
'ANTHROPIC_BASE_URL',
'OPENCODE_BASE_URL',
'OPENCODE_MODEL_CONTEXT_LIMIT',
'OPENCODE_MODEL_OUTPUT_LIMIT',
'OPENCODE_MODEL_INPUT_MODALITIES',
] as const;
const saved = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
afterEach(() => {
for (const k of ENV_KEYS) {
if (saved[k] === undefined) delete process.env[k];
else process.env[k] = saved[k];
}
});
describe('resolveOpenCodePromptModel', () => {
it('splits the configured provider/model for the prompt API', () => {
expect(resolveOpenCodePromptModel({ model: 'openai/gpt-5.6-sol' })).toEqual({
providerID: 'openai',
modelID: 'gpt-5.6-sol',
});
expect(resolveOpenCodePromptModel({ model: 'openrouter/anthropic/claude-sonnet-4' })).toEqual({
providerID: 'openrouter',
modelID: 'anthropic/claude-sonnet-4',
});
});
it('leaves OpenCode its default for a missing or malformed model', () => {
expect(resolveOpenCodePromptModel({})).toBeUndefined();
expect(resolveOpenCodePromptModel({ model: 'gpt-5.6-sol' })).toBeUndefined();
expect(resolveOpenCodePromptModel({ model: 'openai/' })).toBeUndefined();
});
});
describe('buildOpenCodeConfig provider transport', () => {
it('allows the core five-minute human-question window plus transport overhead', () => {
expect(buildOpenCodeConfig({}).experimental).toMatchObject({ mcp_timeout: 330_000 });
});
it('treats a custom provider prefix literally rather than as a regular expression', () => {
process.env.OPENCODE_PROVIDER = 'local[1]';
process.env.OPENCODE_MODEL = 'local[1]/model';
process.env.OPENCODE_SMALL_MODEL = 'local[1]/small';
const config = buildOpenCodeConfig({});
expect(config.provider).toMatchObject({
'local[1]': { models: { model: { id: 'model' }, small: { id: 'small' } } },
});
});
it('uses ProviderOptions.model before the compatibility env fallback', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/legacy-model';
const config = buildOpenCodeConfig({ model: 'openai/typed-model' });
expect(config.model).toBe('openai/typed-model');
});
it('falls back to OPENCODE_MODEL when ProviderOptions.model is omitted', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/legacy-model';
const config = buildOpenCodeConfig({});
expect(config.model).toBe('openai/legacy-model');
});
it('native cloud providers receive the OneCLI placeholder without an endpoint override', () => {
process.env.OPENCODE_PROVIDER = 'anthropic';
process.env.OPENCODE_MODEL = 'anthropic/claude-sonnet-4-6';
delete process.env.ANTHROPIC_BASE_URL;
const config = buildOpenCodeConfig({});
expect(config.provider).toMatchObject({ anthropic: { options: { apiKey: 'nc-opencode-token-v1' } } });
});
it('custom base URL pins the Chat Completions transport', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/some/local-model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
const config = buildOpenCodeConfig({});
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
expect(entry.npm).toBe('@ai-sdk/openai-compatible');
expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1', baseURL: 'https://inference.example.test/v1' });
});
it('no base URL keeps the native transport and still passes inference overrides', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/gpt-5.2';
delete process.env.ANTHROPIC_BASE_URL;
const config = buildOpenCodeConfig({ effort: 'high' });
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1' });
expect(entry.npm).toBeUndefined();
expect(entry.models).toMatchObject({ 'gpt-5.2': { options: { reasoningEffort: 'high' } } });
});
it('openrouter with a base URL keeps its native transport (no pin)', () => {
process.env.OPENCODE_PROVIDER = 'openrouter';
process.env.OPENCODE_MODEL = 'openrouter/some/model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
const config = buildOpenCodeConfig({});
const entry = (config.provider as Record<string, Record<string, unknown>>).openrouter;
expect(entry.npm).toBeUndefined();
});
it('openai with a base URL still pins the Chat Completions transport', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/some/local-model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
const config = buildOpenCodeConfig({});
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
expect(entry.npm).toBe('@ai-sdk/openai-compatible');
});
});
describe('buildOpenCodeConfig model limit', () => {
function limitEnv() {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/some/local-model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
}
function limit(config: Record<string, unknown>) {
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
return (entry.models as Record<string, Record<string, unknown>>)['some/local-model'].limit;
}
// buildOpenCodeConfig logs through console.error (see `log` at the top of
// opencode.ts); capture it so the invalid-input tests can assert on the
// message instead of just the silent absence of a limit. `spyOn(console,
// 'error')` does not intercept calls made from other modules on this Bun
// version, so patch the method directly.
function captureErrors(fn: () => Record<string, unknown>) {
const messages: string[] = [];
const original = console.error;
console.error = ((...args: unknown[]) => {
messages.push(String(args[0]));
}) as typeof console.error;
try {
return { config: fn(), messages };
} finally {
console.error = original;
}
}
it('declares limit.context/output on the registered model when both env vars are set', () => {
limitEnv();
process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '65536';
process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
const config = buildOpenCodeConfig({});
expect(limit(config)).toEqual({ context: 65536, output: 8192 });
});
it('omits limit when the env vars are unset', () => {
limitEnv();
delete process.env.OPENCODE_MODEL_CONTEXT_LIMIT;
delete process.env.OPENCODE_MODEL_OUTPUT_LIMIT;
const config = buildOpenCodeConfig({});
expect(limit(config)).toBeUndefined();
});
it.each([[' '], ['64k'], ['0'], ['-5']])(
'rejects OPENCODE_MODEL_CONTEXT_LIMIT=%p, omits limit, and logs the rejection',
(value) => {
limitEnv();
process.env.OPENCODE_MODEL_CONTEXT_LIMIT = value;
delete process.env.OPENCODE_MODEL_OUTPUT_LIMIT;
const { config, messages } = captureErrors(() => buildOpenCodeConfig({}));
expect(limit(config)).toBeUndefined();
expect(messages.some((m) => m.includes('Ignoring invalid OPENCODE_MODEL_CONTEXT_LIMIT'))).toBe(true);
},
);
it('ignores a set OPENCODE_MODEL_OUTPUT_LIMIT when there is no valid context limit, and logs it', () => {
limitEnv();
delete process.env.OPENCODE_MODEL_CONTEXT_LIMIT;
process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
const { config, messages } = captureErrors(() => buildOpenCodeConfig({}));
expect(limit(config)).toBeUndefined();
expect(
messages.some(
(m) => m.includes('Ignoring OPENCODE_MODEL_OUTPUT_LIMIT') && m.includes('OPENCODE_MODEL_CONTEXT_LIMIT'),
),
).toBe(true);
});
});
describe('buildOpenCodeConfig model input modalities', () => {
function models(config: Record<string, unknown>) {
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
return (entry.models as Record<string, Record<string, unknown>>)['some/local-model'];
}
function customModelEnv() {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/some/local-model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
}
it('declares attachment + modalities so file parts survive the model call', () => {
customModelEnv();
process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'image,pdf';
const model = models(buildOpenCodeConfig({}));
expect(model.attachment).toBe(true);
// `text` is always prepended: the declared input list REPLACES the defaults,
// so omitting it would turn off text input on the model entry.
expect(model.modalities).toEqual({ input: ['text', 'image', 'pdf'], output: ['text'] });
});
it('omits both capability keys when the env var is unset', () => {
customModelEnv();
delete process.env.OPENCODE_MODEL_INPUT_MODALITIES;
const model = models(buildOpenCodeConfig({}));
expect(model.attachment).toBeUndefined();
expect(model.modalities).toBeUndefined();
});
it('omits both capability keys when the env var is empty or only separators', () => {
customModelEnv();
process.env.OPENCODE_MODEL_INPUT_MODALITIES = ' , ,';
const model = models(buildOpenCodeConfig({}));
expect(model.attachment).toBeUndefined();
expect(model.modalities).toBeUndefined();
});
it('drops entries outside the schema enum and keeps the valid ones', () => {
customModelEnv();
process.env.OPENCODE_MODEL_INPUT_MODALITIES = ' IMAGE , hologram, pdf ,image';
const model = models(buildOpenCodeConfig({}));
expect(model.modalities).toEqual({ input: ['text', 'image', 'pdf'], output: ['text'] });
});
it('does not duplicate text when the operator lists it explicitly', () => {
customModelEnv();
process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'text,image';
const model = models(buildOpenCodeConfig({}));
expect(model.modalities).toEqual({ input: ['text', 'image'], output: ['text'] });
});
});
describe('buildOpenCodeConfig small model scope', () => {
function scopeEnv() {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_MODEL = 'openai/main/model';
process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '65536';
process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'image,pdf';
}
function models(config: Record<string, unknown>) {
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
return entry.models as Record<string, Record<string, unknown>>;
}
it('applies limit and modalities to the main model only, leaving a distinct small model bare', () => {
scopeEnv();
process.env.OPENCODE_SMALL_MODEL = 'openai/small/model';
const all = models(buildOpenCodeConfig({}));
expect(all['main/model']).toEqual({
id: 'main/model',
name: 'main/model',
tool_call: true,
limit: { context: 65536, output: 8192 },
attachment: true,
modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
});
// A distinct small model carries neither key — an undeclared context
// window / modality set is the safe default it falls back to.
expect(all['small/model']).toEqual({ id: 'small/model', name: 'small/model', tool_call: true });
});
it('small model unset or equal to the main model keeps the pre-existing single-entry shape', () => {
scopeEnv();
delete process.env.OPENCODE_SMALL_MODEL;
const unset = models(buildOpenCodeConfig({}));
process.env.OPENCODE_SMALL_MODEL = 'openai/main/model'; // same as OPENCODE_MODEL
const same = models(buildOpenCodeConfig({}));
const expected = {
'main/model': {
id: 'main/model',
name: 'main/model',
tool_call: true,
limit: { context: 65536, output: 8192 },
attachment: true,
modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
},
};
expect(unset).toEqual(expected);
expect(same).toEqual(expected);
});
});
// The instructions array is covered in opencode.memory.test.ts, where the
// memory-delivery contract it used to (wrongly) carry now lives.
describe('buildOpenCodeConfig permission', () => {
it('pins `question` to deny deterministically instead of a wildcard string', () => {
const config = buildOpenCodeConfig({});
// A flat 'allow' string previously left `question` to OpenCode's own
// resolution, which produced contradictory rules (question -> deny *
// AND question -> allow * for the same session, observed live). An
// explicit object with one value per category can never produce that:
// there is exactly one entry for `question`, and it is not 'allow'.
expect(typeof config.permission).toBe('object');
expect(config.permission).not.toBe('allow');
const permission = config.permission as Record<string, unknown>;
expect(permission.question).toBe('deny');
});
it('keeps every other known permission category on allow (no capability regression)', () => {
const config = buildOpenCodeConfig({});
const permission = config.permission as Record<string, unknown>;
const nonQuestionKeys = Object.keys(permission).filter((k) => k !== 'question');
expect(nonQuestionKeys.length).toBeGreaterThan(0);
for (const key of nonQuestionKeys) {
expect(permission[key]).toBe('allow');
}
});
});
describe('buildOpenCodeConfig reasoning effort', () => {
function effortEnv() {
process.env.OPENCODE_PROVIDER = 'opencode-go';
process.env.OPENCODE_MODEL = 'opencode-go/deepseek-v4-flash';
process.env.ANTHROPIC_BASE_URL = 'https://opencode.ai/zen/go/v1';
delete process.env.OPENCODE_SMALL_MODEL;
}
function modelOptions(config: Record<string, unknown>, modelId: string) {
const entry = (config.provider as Record<string, Record<string, unknown>>)['opencode-go'];
return (entry.models as Record<string, Record<string, unknown>>)[modelId].options;
}
it('emits reasoningEffort on the main model when the group config sets an effort', () => {
effortEnv();
const config = buildOpenCodeConfig({ effort: 'max' });
expect(modelOptions(config, 'deepseek-v4-flash')).toEqual({ reasoningEffort: 'max' });
});
it('omits model options when no effort is set', () => {
effortEnv();
const config = buildOpenCodeConfig({});
expect(modelOptions(config, 'deepseek-v4-flash')).toBeUndefined();
});
it('leaves a distinct small model untouched', () => {
effortEnv();
process.env.OPENCODE_SMALL_MODEL = 'opencode-go/deepseek-v4-flash-lite';
const config = buildOpenCodeConfig({ effort: 'high' });
expect(modelOptions(config, 'deepseek-v4-flash')).toEqual({ reasoningEffort: 'high' });
expect(modelOptions(config, 'deepseek-v4-flash-lite')).toBeUndefined();
});
});
describe('provider-owned endpoint defaults', () => {
it('uses OpenCode endpoint without changing the historical shared fallback', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.ANTHROPIC_BASE_URL = 'https://claude.example.test';
process.env.OPENCODE_BASE_URL = 'http://localhost:8891/v1';
const config = buildOpenCodeConfig({ model: 'openai/test' });
expect(config.provider).toMatchObject({ openai: { options: { baseURL: 'http://localhost:8891/v1' } } });
expect(process.env.ANTHROPIC_BASE_URL).toBe('https://claude.example.test');
});
it('explicit native endpoint suppresses a shared Claude URL and preserves model limits', () => {
process.env.OPENCODE_PROVIDER = 'openai';
process.env.OPENCODE_BASE_URL = 'native';
process.env.ANTHROPIC_BASE_URL = 'https://claude.example.test';
process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '32768';
process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '4096';
const config = buildOpenCodeConfig({ model: 'openai/test', effort: 'high' });
const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1' });
expect(entry.npm).toBeUndefined();
expect(entry.models).toMatchObject({
test: { limit: { context: 32768, output: 4096 }, options: { reasoningEffort: 'high' } },
});
});
});
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 469k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |