From 57354ac6d765abd2f50ae6bc103e1ec03c2e190b Mon Sep 17 00:00:00 2001 From: Mourad Maatoug Date: Mon, 18 May 2026 17:06:13 +0200 Subject: [PATCH] feat(@omniroute/opencode-provider): model capabilities, agent block, mode block (UI helpers) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adds three UI-surface helpers on top of T1–T8 in PR #2375: A) Model capability flags - ModelCapabilities interface (label, attachment, reasoning, temperature, tool_call) - OMNIROUTE_DEFAULT_MODEL_CAPABILITIES seeds capabilities for all 7 default model ids - OmniRouteProviderOptions.modelCapabilities merges over defaults per id - createOmniRouteProvider emits capability flags inline in models[id], per OpenCode's ProviderConfig.models schema (snake_case JSON keys, optional) - Label precedence: modelCapabilities[id].label > modelLabels[id] > id B) createOmniRouteAgentBlock - OmniRouteAgentRole + OmniRouteAgentBlockOptions + OpenCodeAgentEntry - Emits Record', temperature?, top_p?, tools?: Record, prompt? }> - Only fields present in OpenCode's AgentConfig schema are emitted - Tools normalized to Record per schema (not string[]) - Roles with empty modelId are skipped C) createOmniRouteModesBlock (deprecated alias) - Same shape as createOmniRouteAgentBlock since OpenCode treats top-level 'mode' block identically to 'agent' (both reference AgentConfig) - Helper kept for back-compat; @deprecated tags steer callers to agent Shared helper buildAgentEntry eliminates duplication between A/B helpers. Schema validation - All emitted keys verified against https://opencode.ai/config.json - Removed initially-considered reasoningEffort + max_tokens fields (not in AgentConfig schema) - tools shape changed from string[] to Record per schema Build hygiene - tsconfig.json narrowed to lib: ['ES2022'] + types: ['node'] (no DOM lib leakage); @types/node added as devDep - Tests: 32 → 45 green (+13 net) - Build: ESM 10.39 KB / CJS 11.01 KB / DTS 18.87 KB --- .../opencode-provider/package-lock.json | 57 ++-- @omniroute/opencode-provider/package.json | 1 + @omniroute/opencode-provider/src/index.ts | 246 +++++++++++++++++- .../opencode-provider/tests/index.test.ts | 176 +++++++++++++ @omniroute/opencode-provider/tsconfig.json | 1 + 5 files changed, 437 insertions(+), 44 deletions(-) diff --git a/@omniroute/opencode-provider/package-lock.json b/@omniroute/opencode-provider/package-lock.json index c7b0102595..ad01c86c67 100644 --- a/@omniroute/opencode-provider/package-lock.json +++ b/@omniroute/opencode-provider/package-lock.json @@ -9,6 +9,7 @@ "version": "0.1.0", "license": "MIT", "devDependencies": { + "@types/node": "^20.19.41", "tsup": "^8.5.0", "tsx": "^4.20.0", "typescript": "^5.9.0" @@ -590,9 +591,6 @@ "arm" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -607,9 +605,6 @@ "arm" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -624,9 +619,6 @@ "arm64" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -641,9 +633,6 @@ "arm64" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -658,9 +647,6 @@ "loong64" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -675,9 +661,6 @@ "loong64" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -692,9 +675,6 @@ "ppc64" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -709,9 +689,6 @@ "ppc64" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -726,9 +703,6 @@ "riscv64" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -743,9 +717,6 @@ "riscv64" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -760,9 +731,6 @@ "s390x" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -777,9 +745,6 @@ "x64" ], "dev": true, - "libc": [ - "glibc" - ], "license": "MIT", "optional": true, "os": [ @@ -794,9 +759,6 @@ "x64" ], "dev": true, - "libc": [ - "musl" - ], "license": "MIT", "optional": true, "os": [ @@ -894,6 +856,16 @@ "dev": true, "license": "MIT" }, + "node_modules/@types/node": { + "version": "20.19.41", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz", + "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, "node_modules/acorn": { "version": "8.16.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", @@ -2014,6 +1986,13 @@ "integrity": "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==", "dev": true, "license": "MIT" + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" } } } diff --git a/@omniroute/opencode-provider/package.json b/@omniroute/opencode-provider/package.json index 3259f24da7..6df9e352aa 100644 --- a/@omniroute/opencode-provider/package.json +++ b/@omniroute/opencode-provider/package.json @@ -52,6 +52,7 @@ "access": "public" }, "devDependencies": { + "@types/node": "^20.19.41", "tsup": "^8.5.0", "tsx": "^4.20.0", "typescript": "^5.9.0" diff --git a/@omniroute/opencode-provider/src/index.ts b/@omniroute/opencode-provider/src/index.ts index d13b50afd9..2b9981b56f 100644 --- a/@omniroute/opencode-provider/src/index.ts +++ b/@omniroute/opencode-provider/src/index.ts @@ -55,6 +55,56 @@ export const OMNIROUTE_DEFAULT_OPENCODE_MODELS = [ "gemini-3-flash", ] as const; +/** + * Optional capability flags surfaced to OpenCode's model picker. + * + * OpenCode reads these per-model keys (snake_case in JSON) to render badges + * and to gate features such as image attachments, reasoning mode, temperature + * controls and tool-calling. Omitted flags default to OpenCode's heuristics. + * + * Mirrors the capability shape used by Alph4d0g/opencode-omniroute-auth + * (https://github.com/Alph4d0g/opencode-omniroute-auth, MIT). + */ +export interface ModelCapabilities { + /** Display label shown in the model picker. Falls back to the model id. */ + label?: string; + /** Model accepts image / file attachments. */ + attachment?: boolean; + /** Model exposes a "reasoning" / extended-thinking surface. */ + reasoning?: boolean; + /** Model honours the `temperature` parameter. */ + temperature?: boolean; + /** Model supports tool / function calling. */ + tool_call?: boolean; +} + +/** + * Default per-model capability hints for the curated default catalog. + * + * Conservative defaults: every default model accepts attachments, tool calls + * and temperature; `reasoning` is opt-in per model id. Callers override per + * model via `OmniRouteProviderOptions.modelCapabilities`. + */ +export const OMNIROUTE_DEFAULT_MODEL_CAPABILITIES: Record = { + "cc/claude-opus-4-7": { attachment: true, reasoning: true, temperature: true, tool_call: true }, + "cc/claude-sonnet-4-6": { attachment: true, reasoning: true, temperature: true, tool_call: true }, + "cc/claude-haiku-4-5-20251001": { attachment: true, temperature: true, tool_call: true }, + "claude-opus-4-5-thinking": { + attachment: true, + reasoning: true, + temperature: true, + tool_call: true, + }, + "claude-sonnet-4-5-thinking": { + attachment: true, + reasoning: true, + temperature: true, + tool_call: true, + }, + "gemini-3.1-pro-high": { attachment: true, reasoning: true, temperature: true, tool_call: true }, + "gemini-3-flash": { attachment: true, temperature: true, tool_call: true }, +}; + export interface OmniRouteProviderOptions { /** OmniRoute base URL, with or without trailing `/v1`. Required. */ baseURL: string; @@ -64,8 +114,14 @@ export interface OmniRouteProviderOptions { displayName?: string; /** Override the model catalog. Defaults to `OMNIROUTE_DEFAULT_OPENCODE_MODELS`. */ models?: readonly string[]; - /** Optional human-readable labels keyed by model id. */ + /** Optional human-readable labels keyed by model id. Overridden by `modelCapabilities[id].label`. */ modelLabels?: Record; + /** + * Optional capability overrides keyed by model id. Merged on top of + * `OMNIROUTE_DEFAULT_MODEL_CAPABILITIES` for ids in the default catalog; + * for custom ids the override is used verbatim. + */ + modelCapabilities?: Record; /** * Primary model for OpenCode (top-level `model` key). * Emitted as `"omniroute/"`. When omitted the key is not written. @@ -78,6 +134,15 @@ export interface OmniRouteProviderOptions { smallModel?: string; } +/** Per-model entry written under `provider.omniroute.models[id]`. */ +export interface OpenCodeModelEntry { + name: string; + attachment?: boolean; + reasoning?: boolean; + temperature?: boolean; + tool_call?: boolean; +} + export interface OpenCodeProviderEntry { /** Identifier of the OpenCode runtime package that will speak to OmniRoute. */ npm: typeof OMNIROUTE_PROVIDER_NPM; @@ -89,7 +154,7 @@ export interface OpenCodeProviderEntry { apiKey: string; }; /** Model catalog surfaced to OpenCode. */ - models: Record; + models: Record; } export interface OpenCodeConfigDocument { @@ -144,14 +209,28 @@ export function createOmniRouteProvider(options: OmniRouteProviderOptions): Open : [...OMNIROUTE_DEFAULT_OPENCODE_MODELS]; const labels = options.modelLabels ?? {}; - const models: Record = {}; + const overrides = options.modelCapabilities ?? {}; + const models: Record = {}; const seen = new Set(); for (const raw of modelList) { const id = typeof raw === "string" ? raw.trim() : ""; if (!id || seen.has(id)) continue; seen.add(id); - const label = typeof labels[id] === "string" && labels[id].trim() ? labels[id].trim() : id; - models[id] = { name: label }; + const defaults = OMNIROUTE_DEFAULT_MODEL_CAPABILITIES[id] ?? {}; + const override = overrides[id] ?? {}; + const merged: ModelCapabilities = { ...defaults, ...override }; + const explicitLabel = + typeof merged.label === "string" && merged.label.trim() + ? merged.label.trim() + : typeof labels[id] === "string" && labels[id].trim() + ? labels[id].trim() + : id; + const entry: OpenCodeModelEntry = { name: explicitLabel }; + if (typeof merged.attachment === "boolean") entry.attachment = merged.attachment; + if (typeof merged.reasoning === "boolean") entry.reasoning = merged.reasoning; + if (typeof merged.temperature === "boolean") entry.temperature = merged.temperature; + if (typeof merged.tool_call === "boolean") entry.tool_call = merged.tool_call; + models[id] = entry; } return { @@ -594,4 +673,161 @@ export function createOmniRouteComboConfig( return payload; } +/** + * Override fields supported per agent / mode entry. Mirrors the subset of + * OpenCode's `AgentConfig` schema that is safe to set declaratively from a + * config generator. Only fields present in + * https://opencode.ai/config.json#AgentConfig are exposed. + */ +export interface OmniRouteRoleOverrides { + /** Forward to OpenCode's `temperature` field. */ + temperature?: number; + /** Forward to OpenCode's `top_p` field. */ + top_p?: number; +} + +/** Per-role binding used by `createOmniRouteAgentBlock`. */ +export interface OmniRouteAgentRole extends OmniRouteRoleOverrides { + /** OmniRoute model id, e.g. `"claude-sonnet-4-5-thinking"`. */ + modelId: string; + /** Optional tools allow-list; per OpenCode schema, map of tool name → enabled. */ + tools?: Record; + /** Optional system prompt for this agent role. */ + prompt?: string; +} + +/** Options for `createOmniRouteAgentBlock`. */ +export interface OmniRouteAgentBlockOptions { + /** Per-role bindings. Keys become entries under OpenCode's `agent` block. */ + roles: Record; +} + +/** Single entry inside the emitted OpenCode `agent` block. */ +export interface OpenCodeAgentEntry extends OmniRouteRoleOverrides { + /** Always emitted as `"omniroute/"`. */ + model: string; + /** Per OpenCode schema, `Record`. */ + tools?: Record; + /** Optional system prompt. */ + prompt?: string; +} + +function buildAgentEntry(role: OmniRouteAgentRole): OpenCodeAgentEntry | undefined { + if (!role || typeof role.modelId !== "string") return undefined; + const modelId = role.modelId.trim(); + if (!modelId) return undefined; + const entry: OpenCodeAgentEntry = { model: `${OMNIROUTE_PROVIDER_KEY}/${modelId}` }; + if (typeof role.temperature === "number") entry.temperature = role.temperature; + if (typeof role.top_p === "number") entry.top_p = role.top_p; + if (role.tools && typeof role.tools === "object" && !Array.isArray(role.tools)) { + const tools: Record = {}; + for (const [name, enabled] of Object.entries(role.tools)) { + if (typeof name !== "string" || !name.trim()) continue; + if (typeof enabled !== "boolean") continue; + tools[name] = enabled; + } + if (Object.keys(tools).length > 0) entry.tools = tools; + } + if (typeof role.prompt === "string" && role.prompt.trim()) { + entry.prompt = role.prompt; + } + return entry; +} + +/** + * Build the OpenCode `agent` block, pre-wired so each agent role routes to a + * specific OmniRoute model. Useful for `.opencode/agent/*.md` defaults and + * scaffolded `opencode.json` files. + * + * Emitted fields are limited to those declared in OpenCode's `AgentConfig` + * schema (`model`, `temperature`, `top_p`, `tools`, `prompt`). The `tools` + * field is a `Record` per the schema, not a string array. + * + * Roles with empty / missing `modelId` are skipped. + * + * @example + * ```ts + * const agentBlock = createOmniRouteAgentBlock({ + * roles: { + * build: { modelId: "claude-sonnet-4-5-thinking", temperature: 0.2 }, + * plan: { modelId: "claude-opus-4-5-thinking", top_p: 0.95 }, + * review: { modelId: "gemini-3-flash", tools: { edit: false, bash: false } }, + * }, + * }); + * // -> { build: { model: "omniroute/claude-sonnet-4-5-thinking", temperature: 0.2 }, ... } + * ``` + */ +export function createOmniRouteAgentBlock( + options: OmniRouteAgentBlockOptions +): Record { + const out: Record = {}; + const roles = options.roles ?? {}; + for (const [roleName, role] of Object.entries(roles)) { + const entry = buildAgentEntry(role); + if (entry) out[roleName] = entry; + } + return out; +} + +/** + * Per-mode binding used by `createOmniRouteModesBlock`. + * + * @deprecated OpenCode's top-level `mode` block is deprecated in favour of + * `agent`. Prefer `OmniRouteAgentRole` + `createOmniRouteAgentBlock`. This + * type and the corresponding helper are kept for back-compat with configs + * still using `mode:`. + */ +export interface OmniRouteMode extends OmniRouteAgentRole {} + +/** + * Options for `createOmniRouteModesBlock`. + * + * @deprecated See `OmniRouteMode`. + */ +export interface OmniRouteModesBlockOptions { + /** Per-mode bindings. Keys become entries under OpenCode's deprecated top-level `mode` block. */ + modes: Record; +} + +/** + * Single entry inside the emitted OpenCode `mode` block. + * + * @deprecated See `OmniRouteMode`. + */ +export interface OpenCodeModeEntry extends OpenCodeAgentEntry {} + +/** + * Build the OpenCode top-level `mode` block, pre-wired so each mode routes to + * a specific OmniRoute model. Emits the same shape as the `agent` block since + * OpenCode's schema treats them identically (both reference `AgentConfig`). + * + * Modes with empty / missing `modelId` are skipped. + * + * @deprecated OpenCode's top-level `mode` block is deprecated in favour of + * `agent`. Prefer `createOmniRouteAgentBlock`. This helper is kept for + * back-compat with configs still using `mode:`. + * + * @example + * ```ts + * const modesBlock = createOmniRouteModesBlock({ + * modes: { + * build: { modelId: "claude-sonnet-4-5-thinking", tools: { edit: true, bash: true } }, + * plan: { modelId: "claude-opus-4-5-thinking", prompt: "Plan first, code later." }, + * review: { modelId: "gemini-3-flash" }, + * }, + * }); + * ``` + */ +export function createOmniRouteModesBlock( + options: OmniRouteModesBlockOptions +): Record { + const out: Record = {}; + const modes = options.modes ?? {}; + for (const [modeName, mode] of Object.entries(modes)) { + const entry = buildAgentEntry(mode); + if (entry) out[modeName] = entry; + } + return out; +} + export default createOmniRouteProvider; diff --git a/@omniroute/opencode-provider/tests/index.test.ts b/@omniroute/opencode-provider/tests/index.test.ts index af94f7faf9..324ae68bfa 100644 --- a/@omniroute/opencode-provider/tests/index.test.ts +++ b/@omniroute/opencode-provider/tests/index.test.ts @@ -5,13 +5,16 @@ import type { Server } from "node:http"; import { buildOmniRouteOpenCodeConfig, + createOmniRouteAgentBlock, createOmniRouteComboConfig, createOmniRouteMCPEntry, + createOmniRouteModesBlock, createOmniRouteProvider, fetchLiveModels, listCombos, mergeIntoExistingConfig, normalizeBaseURL, + OMNIROUTE_DEFAULT_MODEL_CAPABILITIES, OMNIROUTE_DEFAULT_OPENCODE_MODELS, OMNIROUTE_MCP_DEFAULT_SCOPES, OMNIROUTE_PROVIDER_NPM, @@ -74,6 +77,7 @@ test("createOmniRouteProvider seeds the default model catalog", () => { assert.deepEqual(modelIds, defaultIds); for (const id of defaultIds) { assert.equal(provider.models[id]?.name, id); + assert.equal(provider.models[id]?.attachment, true); } }); @@ -389,3 +393,175 @@ test("OMNIROUTE_DEFAULT_OPENCODE_MODELS includes cc/ prefixed models", () => { ); assert.ok(defaults.length >= 7, "should have at least 7 models"); }); + +test("OMNIROUTE_DEFAULT_MODEL_CAPABILITIES covers every default model id", () => { + for (const id of OMNIROUTE_DEFAULT_OPENCODE_MODELS) { + const caps = OMNIROUTE_DEFAULT_MODEL_CAPABILITIES[id]; + assert.ok(caps, `default capabilities for ${id} missing`); + assert.equal(caps.attachment, true, `${id} should default to attachment=true`); + assert.equal(caps.tool_call, true, `${id} should default to tool_call=true`); + } +}); + +test("createOmniRouteProvider emits default capability flags inline with the model entry", () => { + const provider = createOmniRouteProvider({ + baseURL: "http://localhost:20128", + apiKey: "sk_omniroute", + }); + const entry = provider.models["cc/claude-opus-4-7"]; + assert.equal(entry.name, "cc/claude-opus-4-7"); + assert.equal(entry.attachment, true); + assert.equal(entry.reasoning, true); + assert.equal(entry.temperature, true); + assert.equal(entry.tool_call, true); +}); + +test("createOmniRouteProvider modelCapabilities overrides defaults and merges per id", () => { + const provider = createOmniRouteProvider({ + baseURL: "http://localhost:20128", + apiKey: "sk_omniroute", + modelCapabilities: { + "cc/claude-opus-4-7": { reasoning: false, label: "Opus (no thinking)" }, + }, + }); + const entry = provider.models["cc/claude-opus-4-7"]; + assert.equal(entry.name, "Opus (no thinking)"); + assert.equal(entry.reasoning, false); + assert.equal(entry.attachment, true); + assert.equal(entry.tool_call, true); +}); + +test("createOmniRouteProvider applies capability overrides to non-default model ids", () => { + const provider = createOmniRouteProvider({ + baseURL: "http://localhost:20128", + apiKey: "sk_omniroute", + models: ["custom-model"], + modelCapabilities: { + "custom-model": { attachment: false, tool_call: true, label: "Custom" }, + }, + }); + const entry = provider.models["custom-model"]; + assert.equal(entry.name, "Custom"); + assert.equal(entry.attachment, false); + assert.equal(entry.tool_call, true); + assert.equal(entry.reasoning, undefined); + assert.equal(entry.temperature, undefined); +}); + +test("createOmniRouteProvider modelLabels still works when modelCapabilities omits label", () => { + const provider = createOmniRouteProvider({ + baseURL: "http://localhost:20128", + apiKey: "sk_omniroute", + models: ["claude-opus-4-5-thinking"], + modelLabels: { "claude-opus-4-5-thinking": "Opus 4.5 (legacy label)" }, + }); + assert.equal(provider.models["claude-opus-4-5-thinking"].name, "Opus 4.5 (legacy label)"); +}); + +test("createOmniRouteAgentBlock builds provider-prefixed entries per role", () => { + const block = createOmniRouteAgentBlock({ + roles: { + build: { modelId: "claude-sonnet-4-5-thinking", temperature: 0.2 }, + plan: { modelId: "claude-opus-4-5-thinking", top_p: 0.95 }, + review: { modelId: "gemini-3-flash", temperature: 0.0 }, + }, + }); + assert.equal(block.build.model, "omniroute/claude-sonnet-4-5-thinking"); + assert.equal(block.build.temperature, 0.2); + assert.equal(block.plan.model, "omniroute/claude-opus-4-5-thinking"); + assert.equal(block.plan.top_p, 0.95); + assert.equal(block.review.model, "omniroute/gemini-3-flash"); + assert.equal(block.review.temperature, 0.0); +}); + +test("createOmniRouteAgentBlock omits optional fields when not supplied", () => { + const block = createOmniRouteAgentBlock({ + roles: { build: { modelId: "claude-sonnet-4-5-thinking" } }, + }); + assert.equal(block.build.model, "omniroute/claude-sonnet-4-5-thinking"); + assert.ok(!("temperature" in block.build)); + assert.ok(!("top_p" in block.build)); + assert.ok(!("tools" in block.build)); + assert.ok(!("prompt" in block.build)); +}); + +test("createOmniRouteAgentBlock skips roles with empty modelId", () => { + const block = createOmniRouteAgentBlock({ + roles: { + build: { modelId: "claude-sonnet-4-5-thinking" }, + plan: { modelId: " " }, + review: { modelId: "" }, + }, + }); + assert.deepEqual(Object.keys(block), ["build"]); +}); + +test("createOmniRouteAgentBlock emits tools as Record per OC schema", () => { + const block = createOmniRouteAgentBlock({ + roles: { + build: { + modelId: "claude-sonnet-4-5-thinking", + tools: { edit: true, bash: true, web: false }, + prompt: "Edit files carefully.", + }, + }, + }); + assert.deepEqual(block.build.tools, { edit: true, bash: true, web: false }); + assert.equal(block.build.prompt, "Edit files carefully."); +}); + +test("createOmniRouteAgentBlock filters invalid tool entries and omits empty maps", () => { + const block = createOmniRouteAgentBlock({ + roles: { + build: { + modelId: "claude-sonnet-4-5-thinking", + // @ts-expect-error — exercising runtime guard against bad input + tools: { edit: true, bash: "yes", "": true, web: null }, + }, + plan: { + modelId: "claude-opus-4-5-thinking", + tools: {}, + }, + }, + }); + assert.deepEqual(block.build.tools, { edit: true }); + assert.ok(!("tools" in block.plan)); +}); + +test("createOmniRouteModesBlock builds provider-prefixed mode entries", () => { + const block = createOmniRouteModesBlock({ + modes: { + build: { modelId: "claude-sonnet-4-5-thinking", tools: { edit: true, bash: true } }, + plan: { modelId: "claude-opus-4-5-thinking", prompt: "Plan first, code later." }, + review: { modelId: "gemini-3-flash" }, + }, + }); + assert.equal(block.build.model, "omniroute/claude-sonnet-4-5-thinking"); + assert.deepEqual(block.build.tools, { edit: true, bash: true }); + assert.equal(block.plan.prompt, "Plan first, code later."); + assert.equal(block.review.model, "omniroute/gemini-3-flash"); +}); + +test("createOmniRouteModesBlock skips modes with empty modelId", () => { + const block = createOmniRouteModesBlock({ + modes: { + build: { modelId: "claude-sonnet-4-5-thinking" }, + plan: { modelId: "" }, + }, + }); + assert.deepEqual(Object.keys(block), ["build"]); +}); + +test("createOmniRouteModesBlock honours numeric overrides limited to OC schema", () => { + const block = createOmniRouteModesBlock({ + modes: { + build: { + modelId: "claude-sonnet-4-5-thinking", + temperature: 0.7, + top_p: 0.9, + }, + }, + }); + assert.equal(block.build.temperature, 0.7); + assert.equal(block.build.top_p, 0.9); +}); diff --git a/@omniroute/opencode-provider/tsconfig.json b/@omniroute/opencode-provider/tsconfig.json index ac1430ae95..05ee599fbc 100644 --- a/@omniroute/opencode-provider/tsconfig.json +++ b/@omniroute/opencode-provider/tsconfig.json @@ -4,6 +4,7 @@ "module": "ESNext", "moduleResolution": "Bundler", "lib": ["ES2022"], + "types": ["node"], "strict": true, "esModuleInterop": true, "skipLibCheck": true,