@staticeng/opencode-litellm 0.2.7 → 0.3.1

package/README.md

@@ -4,23 +4,20 @@ Runtime LiteLLM model autodiscovery for OpenCode. The plugin fetches LiteLLM dep
 
 ## Install
 
-Install the package by npm name, then add it to OpenCode `plugin` config:
-
-```sh
-npm install @staticeng/opencode-litellm
-```
+For OpenCode V2, add the published package to `~/.config/opencode/opencode.json`.
+OpenCode downloads npm plugins automatically; no manual `npm install` is needed.
 
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": [
-    [
-      "@staticeng/opencode-litellm",
-      {
+  "plugins": [
+    {
+      "package": "@staticeng/opencode-litellm@0.3.0",
+      "options": {
         "baseURL": "https://litellm.example.com/v1",
         "apiKeyEnv": "LITELLM_API_KEY"
       }
-    ]
+    }
   ]
 }
 ```
@@ -35,6 +32,16 @@ Do not put real API keys in `opencode.json`. If you pass `apiKey` directly, the
 
 Shared or synchronized OpenCode configuration should use the published package name as shown above. Do not use a local path or `file://` plugin reference for shared configuration.
 
+Version 0.3.0 exposes native V2 `id`/`setup` and a V1 `server` entrypoint.
+V1 object entrypoints require OpenCode 1.18.29 or newer; use the V1 `plugin`
+package-and-options tuple on those releases. OpenCode V2 uses `plugins` and
+the object shown above. Versions through 0.2.7 only expose V1 hooks.
+
+After changing the package version, reload configuration or start a new OpenCode
+process, then use `/models` to select a model under `LiteLLM`. For synchronized
+setups, edit the authoritative configuration once and wait for Syncthing to
+deliver it to each peer. Each host installs its own npm package cache.
+
 ## Options
 
 | Option | Default | Purpose |
@@ -42,7 +49,7 @@ Shared or synchronized OpenCode configuration should use the published package n
 | `baseURL` | `LITELLM_BASE_URL` | LiteLLM proxy base URL. `/v1` URLs are supported. |
 | `apiKey` | env value | Bearer token for LiteLLM. |
 | `apiKeyEnv` | `LITELLM_API_KEY` | Environment variable used when `apiKey` is not set. |
-| `providerKey` | `LiteLLM` | Key written to legacy `cfg.provider` and V2 `cfg.providers`. |
+| `providerKey` | `LiteLLM` | Provider ID registered in OpenCode. |
 | `providerName` | `LiteLLM` | Human provider name. |
 | `overrides` | `{}` | Per-model deep-merge overrides. |
 | `providerOverrides` | `{}` | Provider-level deep-merge overrides. |
@@ -65,19 +72,26 @@ When LiteLLM publishes `model_info.supported_reasoning_efforts`, the plugin maps
 
 ```json
 {
-  "plugin": [
-    [
-      "@staticeng/opencode-litellm",
-      {
+  "plugins": [
+    {
+      "package": "@staticeng/opencode-litellm@0.3.0",
+      "options": {
         "baseURL": "https://litellm.example.com/v1",
         "apiKeyEnv": "LITELLM_API_KEY",
         "overrides": {
           "chatgpt/gpt-5.5": {
-            "limit": { "context": 262144, "output": 128000 },
+            "limit": {
+              "context": 262144,
+              "output": 128000
+            },
             "variants": {
-              "high": { "reasoningEffort": "high" }
+              "high": {
+                "reasoningEffort": "high"
+              }
             },
-            "interleaved": { "field": "reasoning_details" }
+            "interleaved": {
+              "field": "reasoning_details"
+            }
           }
         },
         "providerOverrides": {
@@ -86,7 +100,7 @@ When LiteLLM publishes `model_info.supported_reasoning_efforts`, the plugin maps
           }
         }
       }
-    ]
+    }
   ]
 }
 ```
@@ -139,7 +153,7 @@ Normal GPT-5.3 Codex and GPT-5.3 Codex Spark aliases are retired and filtered ev
 
 - Fetches `${baseURL}/model/info`, then root `/model_group/info`, with separate authenticated and timed requests.
 - Preserves `/v1` for model-info discovery but resolves model-group discovery from the LiteLLM origin.
-- Adds or replaces both legacy `cfg.provider[providerKey]` and V2 `cfg.providers[providerKey]` during the config hook.
+- Registers the provider and models with the native V2 provider transform API; V1 uses the config hook.
 - Keeps namespaced deployment IDs and augments them with exact bare model-group IDs; exact collisions are enriched deterministically.
 - Skips malformed group rows without a nonblank `model_group` and exposes reasoning capability on legacy and V2 model metadata.
 - Applies exact built-in model contracts as defaults, then applies explicit model and provider overrides last.
@@ -164,7 +178,13 @@ npm pack --dry-run
 
 Confirm package contents before publishing and keep secrets out of fixtures, docs, logs, and config examples.
 
-Publishing uses npm trusted publishing from the `npm-production` GitHub environment. Provenance
+The GitHub release workflow supports npm trusted publishing from the `npm-production` environment. Provenance
 requires this GitHub repository to remain public. Before a release, configure npm's trusted
 publisher for package `@staticeng/opencode-litellm` with this repository, workflow
 `publish.yml`, and environment `npm-production`; no npm token is used by the workflow.
+
+### Local RTX 5090 Strata aliases
+
+The exact discovered aliases `5090-local-model` and `5090-local-model-codex` use the Qwen3.8 Flash Next Strata contract: text/image input, text output, reasoning, tools, and 262144 tokens of shared context. The output ceiling is 262144 within that shared window; it is not an additional output budget. Pricing continues to come from LiteLLM metadata.
+
+Both aliases preserve their routable IDs and use Chat Completions in OpenCode. Their public variants are `off`, `low`, `medium`, and `high` (default `high`): `off` sends `reasoning_effort: "none"`; the other variants send their named effort. Strata translates public `high` to its native engine effort. This differs from the cloud Qwen contract and does not alter it. The `-codex` alias remains available to Codex via LiteLLM's separate Responses adapter. No alias is fabricated when discovery omits it; explicit model/provider overrides still win.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { Config, PluginInput } from "@opencode-ai/plugin";
 import type { LiteLLMPluginOptions } from "./types.js";
-declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOptions) => Promise<{
+export declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOptions) => Promise<{
     config: (cfg: Config) => Promise<void>;
     "chat.params": (input: {
         sessionID: string;
@@ -16,4 +16,24 @@ declare const LiteLLMPlugin: (ctx: PluginInput, options?: LiteLLMPluginOptions)
         options: Record<string, any>;
     }) => Promise<void>;
 }>;
-export default LiteLLMPlugin;
+declare const _default: {
+    id: string;
+    server: (ctx: PluginInput, options?: LiteLLMPluginOptions) => Promise<{
+        config: (cfg: Config) => Promise<void>;
+        "chat.params": (input: {
+            sessionID: string;
+            agent: string;
+            model: import("@opencode-ai/sdk").Model;
+            provider: import("@opencode-ai/plugin").ProviderContext;
+            message: import("@opencode-ai/sdk").UserMessage;
+        }, output: {
+            temperature: number;
+            topP: number;
+            topK: number;
+            maxOutputTokens: number | undefined;
+            options: Record<string, any>;
+        }) => Promise<void>;
+    }>;
+    setup: (ctx: import("@opencode/plugin/promise/plugin").Context) => Promise<void>;
+};
+export default _default;

package/dist/index.js

@@ -1,10 +1,11 @@
 import { fetchModelGroupInfo, fetchModelInfo } from "./litellm.js";
 import { buildProvider, buildProviderV2, isContractReasoningModel, isQwen38ReasoningModel, mergeModelInfo, } from "./mapping.js";
 import { resolveOptions } from "./options.js";
+import V2Plugin from "./v2.js";
 async function log(ctx, level, message, extra = {}) {
     await ctx.client?.app?.log?.({ body: { service: "opencode-litellm", level, message, extra } });
 }
-const LiteLLMPlugin = async (ctx, options) => {
+export const LiteLLMPlugin = async (ctx, options) => {
     const resolved = resolveOptions(options);
     return {
         config: async (cfg) => {
@@ -68,4 +69,8 @@ const LiteLLMPlugin = async (ctx, options) => {
         }),
     };
 };
-export default LiteLLMPlugin;
+export default {
+    id: V2Plugin.id,
+    server: LiteLLMPlugin,
+    setup: V2Plugin.setup,
+};

package/dist/mapping.js

@@ -464,9 +464,24 @@ export function mapModelsV2(models, options = {}) {
         const mapped = v2Model(model, options.baseURL);
         const variants = contractV2Variants(name, model, options.overrides?.[name]);
         const result = variants ? { ...mapped, variants } : mapped;
+        const contract = modelContract(name);
+        const defaultBody = isRecord(model.options) ? v2VariantBody(model.options) : {};
+        delete defaultBody.variantDefault;
+        const overriddenOptions = options.overrides?.[name]?.options;
+        const overridesEffort = isRecord(overriddenOptions) && ("reasoningEffort" in overriddenOptions ||
+            "reasoning_effort" in overriddenOptions ||
+            "chat_template_kwargs" in overriddenOptions);
+        // V2 applies the selected variant after request.body, so Qwen off must not inherit its default effort.
+        if (contract && mapped.api?.package !== "@ai-sdk/openai" && !overridesEffort) {
+            delete defaultBody.reasoning_effort;
+            delete defaultBody.reasoningEffort;
+        }
+        result.request = {
+            body: defaultBody,
+            ...(contract && !overridesEffort ? { variant: contract.defaultMode } : {}),
+        };
         if (mapped.api?.package === "@ai-sdk/openai") {
-            const body = responsesBody(isRecord(model.options) ? model.options : {});
-            result.request = { body };
+            result.request.body = responsesBody(result.request.body ?? {});
             result.variants = result.variants?.map((variant) => ({ ...variant, body: responsesBody(variant.body ?? {}) }));
         }
         return [name, result];

package/dist/model-contracts.js

@@ -54,6 +54,15 @@ const QWEN_FLASH_NEXT_METADATA = Object.freeze({
     tool_call: true,
     limit: Object.freeze({ context: 262144, output: 0 }),
 });
+// Strata exposes high publicly and translates it to the engine's native effort.
+const STRATA_QWEN_MODES = Object.freeze([
+    Object.freeze({ id: "off", legacy: freezeJson({ reasoningEffort: "none" }), v2Body: freezeJson({ reasoning_effort: "none" }) }),
+    ...effortModes(["low", "medium", "high"]),
+]);
+const STRATA_QWEN_METADATA = Object.freeze({
+    ...QWEN_FLASH_NEXT_METADATA,
+    limit: Object.freeze({ context: 262144, output: 262144 }),
+});
 const chatGptAliases = (model) => Object.freeze([
     model,
     `chatgpt/${model}`,
@@ -73,6 +82,7 @@ export const MODEL_CONTRACTS = Object.freeze([
     contract("DeepSeek V4 Flash", ["deepseek-v4-flash-fp8-mtp", "deepseek-v4-flash-fp8-mtp-norefusal"], DEEPSEEK_MODES, "max"),
     contract("Qwen3.8", ["qwen3.8-27b-refusal-dial"], QWEN_MODES, "xhigh"),
     contract("Qwen3.8", ["qwen3.8-flash-next"], QWEN_MODES, "xhigh", QWEN_FLASH_NEXT_METADATA, true),
+    contract("Qwen3.8 Strata", ["5090-local-model", "5090-local-model-codex"], STRATA_QWEN_MODES, "high", STRATA_QWEN_METADATA, true),
 ]);
 export const RETIRED_MODEL_ALIASES = Object.freeze([
     ...chatGptAliases("gpt-5.3-codex"),

package/dist/v2.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin as CurrentPlugin } from "@opencode/plugin";
+type CurrentContext = Parameters<CurrentPlugin.Plugin["setup"]>[0];
+declare const LiteLLMPluginV2: {
+    id: string;
+    setup: (ctx: CurrentContext) => Promise<void>;
+};
+export default LiteLLMPluginV2;

package/dist/v2.js

@@ -0,0 +1,287 @@
+import { fetchModelGroupInfo, fetchModelInfo } from "./litellm.js";
+import { buildProviderV2, mergeModelInfo } from "./mapping.js";
+import { deepMerge } from "./merge.js";
+import { resolveOptions } from "./options.js";
+const CHAT_PACKAGE = "@opencode/ai/providers/openai-compatible";
+// The 2.0.16 binary bundles this driver, but not openai-compatible/responses.
+const RESPONSES_PACKAGE = "@opencode/ai/providers/openai/responses";
+function packageName(name) {
+    if (name === "@ai-sdk/openai" || name === "@opencode/ai/providers/openai-compatible/responses")
+        return RESPONSES_PACKAGE;
+    if (name === "@ai-sdk/openai-compatible")
+        return CHAT_PACKAGE;
+    return name;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function costTiers(cost) {
+    if (cost === undefined)
+        return [];
+    return (Array.isArray(cost) ? cost : [cost]).map((tier) => ({
+        ...(tier.tier ? { tier: { ...tier.tier } } : {}),
+        input: tier.input,
+        output: tier.output,
+        cache: { read: tier.cache?.read ?? 0, write: tier.cache?.write ?? 0 },
+    }));
+}
+function currentProviderPackage(config) {
+    return packageName(typeof config.npm === "string" ? config.npm : config.api.package);
+}
+function currentModelPackage(config, providerPackage) {
+    return packageName(config.api?.package === "@ai-sdk/openai-compatible" ? providerPackage : config.api?.package ?? providerPackage);
+}
+function currentModel(providerID, id, config, providerPackage) {
+    const settings = {
+        ...config.api?.settings,
+        ...(config.api?.url ? { baseURL: config.api.url } : {}),
+    };
+    const body = { ...config.request?.body };
+    // Current V2 has no default-variant field; a session hook supplies that effort for default requests.
+    delete body.reasoning_effort;
+    delete body.reasoningEffort;
+    if (isRecord(body.reasoning)) {
+        const { effort: _effort, ...reasoning } = body.reasoning;
+        if (Object.keys(reasoning).length)
+            body.reasoning = reasoning;
+        else
+            delete body.reasoning;
+    }
+    return {
+        id,
+        modelID: config.api?.id ?? id,
+        providerID,
+        name: config.name ?? id,
+        ...(config.family ? { family: config.family } : {}),
+        package: currentModelPackage(config, providerPackage),
+        ...(Object.keys(settings).length ? { settings } : {}),
+        ...(config.request?.headers ? { headers: { ...config.request.headers } } : {}),
+        ...(Object.keys(body).length ? { body } : {}),
+        capabilities: {
+            tools: config.capabilities?.tools ?? false,
+            input: [...(config.capabilities?.input ?? ["text"])],
+            output: [...(config.capabilities?.output ?? ["text"])],
+        },
+        variants: (config.variants ?? []).map((variant) => ({
+            id: variant.id,
+            ...(variant.headers ? { headers: { ...variant.headers } } : {}),
+            ...(variant.body ? { body: { ...variant.body } } : {}),
+        })),
+        time: { released: 0 },
+        cost: costTiers(config.cost),
+        status: "active",
+        enabled: !config.disabled,
+        limit: {
+            context: config.limit?.context ?? 0,
+            ...(config.limit?.input === undefined ? {} : { input: config.limit.input }),
+            output: config.limit?.output ?? 0,
+        },
+    };
+}
+function defaultVariants(provider) {
+    return new Map(Object.entries(provider.models).flatMap(([id, model]) => {
+        const selected = model.variants?.find((variant) => variant.id === model.request?.variant);
+        return selected ? [[id, selected]] : [];
+    }));
+}
+function defaultEfforts(provider) {
+    const variants = defaultVariants(provider);
+    return new Map(Object.entries(provider.models).flatMap(([id, model]) => {
+        const selected = variants.get(id);
+        const body = selected?.body ?? model.request?.body;
+        const reasoning = body?.reasoning;
+        const effort = typeof reasoning === "object" && reasoning !== null && !Array.isArray(reasoning)
+            ? reasoning.effort
+            : body?.reasoning_effort ?? body?.reasoningEffort;
+        return typeof effort === "string" ? [[id, effort]] : [];
+    }));
+}
+async function registerCurrent(ctx, providerID, config) {
+    const providerOptions = isRecord(config.options) ? config.options : {};
+    const { body: optionBody, ...optionSettings } = providerOptions;
+    const providerPackage = currentProviderPackage(config);
+    const mergedBody = deepMerge(config.request.body, isRecord(optionBody) ? optionBody : undefined);
+    const { apiKey, ...body } = mergedBody;
+    const settings = {
+        ...(typeof config.request.body.apiKey === "string" ? { apiKey: config.request.body.apiKey } : {}),
+        ...config.api.settings,
+        ...(config.api.url ? { baseURL: config.api.url } : {}),
+        ...(isRecord(optionBody) && typeof optionBody.apiKey === "string" ? { apiKey: optionBody.apiKey } : {}),
+        ...optionSettings,
+    };
+    const models = Object.entries(config.models).map(([id, model]) => currentModel(providerID, id, model, providerPackage));
+    await ctx.provider.transform((editor) => {
+        editor.update(providerID, (provider) => {
+            provider.name = config.name ?? providerID;
+            provider.activation = config.disabled ? "disabled" : "enabled";
+            provider.package = providerPackage;
+            provider.settings = { ...settings };
+            provider.headers = { ...config.request.headers };
+            provider.body = { ...body };
+            if (typeof config.integrationID === "string")
+                provider.integrationID = config.integrationID;
+        });
+        editor.models.set(providerID, models);
+    });
+    const defaults = defaultEfforts(config);
+    if (defaults.size) {
+        for (const hook of ["context", "compaction", "generate", "title"]) {
+            await ctx.session.hook(hook, (event) => {
+                if (event.model.providerID !== providerID || (event.model.variant && event.model.variant !== "default"))
+                    return;
+                const effort = defaults.get(event.model.id);
+                if (effort && event.options.reasoningEffort === undefined)
+                    event.options.reasoningEffort = effort;
+            });
+        }
+    }
+    const variants = defaultVariants(config);
+    if (variants.size) {
+        await ctx.session.hook("http.request", async (event) => {
+            if (event.model.providerID !== providerID || (event.model.variant && event.model.variant !== "default"))
+                return;
+            const selected = variants.get(event.model.id);
+            if (!selected)
+                return;
+            const headers = new Headers(event.request.headers);
+            for (const [name, value] of Object.entries(selected.headers ?? {}))
+                headers.set(name, value);
+            if (!selected.body || !Object.keys(selected.body).length) {
+                event.request = new Request(event.request, { headers });
+                return;
+            }
+            let wireBody;
+            try {
+                wireBody = JSON.parse(await event.request.clone().text());
+            }
+            catch {
+                return;
+            }
+            if (!isRecord(wireBody))
+                return;
+            const merged = deepMerge(wireBody, selected.body);
+            // A request-level effort already serialized by the driver takes precedence.
+            for (const key of ["reasoning_effort", "reasoningEffort"]) {
+                if (key in wireBody)
+                    merged[key] = wireBody[key];
+            }
+            if (isRecord(wireBody.reasoning) && "effort" in wireBody.reasoning && isRecord(merged.reasoning)) {
+                merged.reasoning.effort = wireBody.reasoning.effort;
+            }
+            headers.delete("content-length");
+            event.request = new Request(event.request, { headers, body: JSON.stringify(merged) });
+        }, { providerID });
+    }
+}
+function applyTransitionalModel(catalog, providerID, id, config) {
+    catalog.model.update(providerID, id, (model) => {
+        if (config.family !== undefined)
+            model.family = config.family;
+        if (config.name !== undefined)
+            model.name = config.name;
+        if (config.api !== undefined)
+            model.api = {
+                ...model.api, ...config.api, id: config.api.id ?? id, type: "aisdk", package: config.api.package,
+            };
+        if (config.capabilities !== undefined)
+            model.capabilities = {
+                tools: config.capabilities.tools,
+                input: [...config.capabilities.input],
+                output: [...config.capabilities.output],
+            };
+        if (config.request !== undefined) {
+            Object.assign(model.request.headers, config.request.headers);
+            Object.assign(model.request.body, config.request.body);
+            if (config.request.variant !== undefined)
+                model.request.variant = config.request.variant;
+        }
+        if (config.variants !== undefined)
+            model.variants = config.variants.map((variant) => ({
+                id: variant.id, headers: { ...variant.headers }, body: { ...variant.body },
+            }));
+        if (config.cost !== undefined)
+            model.cost = costTiers(config.cost);
+        if (config.disabled !== undefined)
+            model.enabled = !config.disabled;
+        if (config.limit !== undefined)
+            model.limit = { ...model.limit, ...config.limit };
+    });
+}
+function applyTransitional(catalog, providerID, config) {
+    catalog.provider.update(providerID, (provider) => {
+        if (config.name !== undefined)
+            provider.name = config.name;
+        provider.api = { ...config.api };
+        Object.assign(provider.request.headers, config.request.headers);
+        Object.assign(provider.request.body, config.request.body);
+        if (typeof config.disabled === "boolean")
+            provider.disabled = config.disabled;
+        if (typeof config.integrationID === "string")
+            provider.integrationID = config.integrationID;
+    });
+    for (const [id, model] of Object.entries(config.models))
+        applyTransitionalModel(catalog, providerID, id, model);
+}
+const LiteLLMPluginV2 = {
+    id: "opencode-litellm",
+    setup: async (ctx) => {
+        const options = resolveOptions(ctx.options);
+        let provider;
+        try {
+            const deployments = await fetchModelInfo(options);
+            let groups = [];
+            try {
+                groups = await fetchModelGroupInfo(options);
+            }
+            catch (error) {
+                if (options.strict)
+                    throw error;
+                console.warn("opencode-litellm: failed to load LiteLLM model group metadata", error instanceof Error ? error.message : String(error));
+            }
+            const models = mergeModelInfo(deployments, groups);
+            if (ctx.provider?.transform) {
+                const overrides = { ...options.overrides };
+                for (const model of models) {
+                    if (model.model_info?.mode !== "responses")
+                        continue;
+                    const id = model.model_name ?? model.litellm_params?.model ?? model.model_info?.id;
+                    if (!id)
+                        continue;
+                    // Opaque Responses aliases need the same transport as GPT-named models.
+                    overrides[id] = deepMerge({ provider: { npm: "@ai-sdk/openai" } }, overrides[id]);
+                }
+                provider = buildProviderV2(models, { ...options, overrides });
+                for (const model of models) {
+                    if (model.model_info?.use_responses_lite !== true)
+                        continue;
+                    const id = model.model_name ?? model.litellm_params?.model ?? model.model_info?.id;
+                    const mapped = id ? provider.models[id] : undefined;
+                    if (!mapped || currentModelPackage(mapped, currentProviderPackage(provider)) !== RESPONSES_PACKAGE)
+                        continue;
+                    mapped.request ??= {};
+                    mapped.request.body = deepMerge({ reasoning: { context: "all_turns" } }, mapped.request.body);
+                }
+            }
+            else {
+                provider = buildProviderV2(models, options);
+            }
+        }
+        catch (error) {
+            if (options.strict)
+                throw error;
+            console.warn("opencode-litellm: failed to load LiteLLM provider metadata", error instanceof Error ? error.message : String(error));
+            return;
+        }
+        if (ctx.provider?.transform) {
+            await registerCurrent(ctx, options.providerKey, provider);
+            return;
+        }
+        const transitional = ctx;
+        if (transitional.catalog?.transform) {
+            await transitional.catalog.transform((catalog) => applyTransitional(catalog, options.providerKey, provider));
+            return;
+        }
+        throw new Error("opencode-litellm requires an OpenCode V2 provider or catalog transform API");
+    },
+};
+export default LiteLLMPluginV2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staticeng/opencode-litellm",
-  "version": "0.2.7",
+  "version": "0.3.1",
   "description": "OpenCode plugin that discovers LiteLLM models at runtime.",
   "type": "module",
   "license": "MIT",
@@ -14,6 +14,10 @@
     "./helpers": {
       "types": "./dist/helpers.d.ts",
       "import": "./dist/helpers.js"
+    },
+    "./v2": {
+      "types": "./dist/v2.d.ts",
+      "import": "./dist/v2.js"
     }
   },
   "files": [
@@ -27,13 +31,25 @@
     "prepack": "npm run build"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": "*"
+    "@opencode-ai/plugin": ">=1.18.29",
+    "@opencode/plugin": ">=2.0.16"
+  },
+  "peerDependenciesMeta": {
+    "@opencode-ai/plugin": {
+      "optional": true
+    },
+    "@opencode/plugin": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@ai-sdk/openai": "3.0.84",
     "@ai-sdk/openai-compatible": "2.0.41",
-    "@opencode-ai/plugin": "latest",
+    "@opencode-ai/plugin": "1.18.32",
+    "@opencode/ai": "2.0.16",
+    "@opencode/plugin": "2.0.16",
     "@types/node": "^24.10.1",
+    "effect": "4.0.0-rc.112",
     "typescript": "^5.9.3"
   },
   "engines": {