@darknesskiller/opencode-cliproxyapi 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
+and this project follows [Semantic Versioning](https://semver.org/).
+
+## [0.2.0] - 2026-09-09
+
+### Added
+
+- Auto-configure reasoning effort per model from CLIProxyAPI's own model
+  catalog. Models the server reports with supported reasoning levels are
+  marked as reasoning models, get their default effort configured, and expose
+  every supported effort as an OpenCode model variant for the variant-cycle
+  keybind.
+- Query CLIProxyAPI's codex-client model catalog (`/v1/models?client_version=`)
+  to discover per-model reasoning levels at startup.
+
+### Changed
+
+- A model's `reasoning` flag now prefers CLIProxyAPI's reported effort levels
+  over the previous id-based heuristic; the heuristic remains the fallback for
+  servers that do not report levels.
+
+## [0.1.2] - 2026-07-28
+
+### Fixed
+
+- Dynamically route models with Anthropic protocol metadata through
+  `/v1/messages` instead of OpenAI-compatible chat completions, without
+  hard-coding model IDs.
+- Preserve discovered model protocol metadata when users customize individual
+  model settings.
+
+## [0.1.1] - 2026-07-25
+
+### Changed
+
+- Made persistent global OpenCode configuration the recommended setup flow.
+- Moved temporary environment-variable setup to an optional alternative.
+- Clarified API-key handling and troubleshooting.
+
+## [0.1.0] - 2026-07-25
+
+### Added
+
+- Dynamic model discovery from CLIProxyAPI's `/v1/models` endpoint.
+- OpenCode provider configuration for OpenAI-compatible chat completions.
+- Custom server URL and API key support through environment variables or
+  plugin options.
+- Automatic model names and capability hints in OpenCode's model picker.
+- Local plugin and npm package installation flows.
+
+[Unreleased]: https://github.com/DarknessKiller/opencode-cliproxyapi/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/DarknessKiller/opencode-cliproxyapi/compare/v0.1.2...v0.2.0
+[0.1.2]: https://github.com/DarknessKiller/opencode-cliproxyapi/compare/v0.1.1...v0.1.2
+[0.1.1]: https://github.com/DarknessKiller/opencode-cliproxyapi/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/DarknessKiller/opencode-cliproxyapi/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 İbrahim BABAL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,235 @@
+# OpenCode CLIProxyAPI
+
+[![CI](https://github.com/DarknessKiller/opencode-cliproxyapi/actions/workflows/ci.yml/badge.svg)](https://github.com/DarknessKiller/opencode-cliproxyapi/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/@darknesskiller/opencode-cliproxyapi)](https://www.npmjs.com/package/@darknesskiller/opencode-cliproxyapi)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Fork of [opencode-cliproxyapi](https://github.com/yourcasualdev/opencode-cliproxyapi)
+that uses every model exposed by [CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI)
+directly in [OpenCode](https://opencode.ai/). This fork adds automatic
+reasoning-effort configuration queried from the CLIProxyAPI server itself.
+
+The plugin discovers CLIProxyAPI's live `/v1/models` catalog whenever OpenCode
+starts. Available models appear in the normal `/models` picker under
+**CLIProxyAPI**. OpenCode Go models that expose Anthropic-compatible endpoints
+are automatically routed through `/v1/messages` using live model metadata from
+[models.dev](https://models.dev/); the remaining discovered models continue to
+use the provider's configured default protocol. No model IDs are hard-coded.
+
+For every model whose reasoning levels are known to the CLIProxyAPI server
+itself, the plugin also:
+
+- marks the model as a reasoning model,
+- sets the server-reported default reasoning effort as the model default, and
+- registers each supported effort (`low`, `medium`, `high`, …) as a model
+  variant you can cycle with the variant keybind.
+
+Effort levels are taken from CLIProxyAPI's codex-client catalog (the same data
+its Codex clients use), so models that the server cannot describe keep the
+plugin's previous id-based heuristics.
+
+## Quick start
+
+You need OpenCode, a running CLIProxyAPI server, and one of its API keys.
+
+### 1. Install from npm
+
+The plugin is published as `@darknesskiller/opencode-cliproxyapi`. OpenCode
+installs npm plugins automatically when it starts, so listing the package in
+your config (next step) is enough — no manual download or build.
+
+### 2. Save your connection
+
+Open your global OpenCode config:
+
+```text
+~/.config/opencode/opencode.json
+```
+
+Create it if it does not exist; either `opencode.json` or `opencode.jsonc`
+works. Configure the plugin entry with the npm package name, plus your
+persistent server URL and API key:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@darknesskiller/opencode-cliproxyapi",
+      {
+        "baseURL": "http://your-server:8317",
+        "apiKey": "your-cli-proxy-api-key"
+      }
+    ]
+  ]
+}
+```
+
+The first OpenCode start downloads the package; later releases are picked up
+after OpenCode restarts. Do not install the original
+`opencode-cliproxyapi` package at the same time — both register the same
+`cliproxyapi` provider.
+
+The URL may include `/v1`, but it is not required. If `baseURL` is omitted, the
+plugin uses `http://localhost:8317/v1`.
+
+Keep this global config private because it contains your API key. Do not copy
+the connection into a project's `opencode.json` or commit it to a repository.
+
+### 3. Verify
+
+```bash
+opencode models cliproxyapi
+```
+
+You should see models reported by your server:
+
+```text
+cliproxyapi/claude-sonnet-4-6
+cliproxyapi/gpt-5.6-terra
+cliproxyapi/gemini-3.1-pro-low
+```
+
+### 4. Select a model
+
+Start OpenCode and run `/models`:
+
+```bash
+opencode
+```
+
+Choose **CLIProxyAPI**, select a model, and use OpenCode normally. Restart
+OpenCode whenever the model catalog on CLIProxyAPI changes.
+
+> This release stores the connection in OpenCode's global config instead of
+> using the `/connect` screen. Model selection itself uses the standard
+> `/models` experience.
+
+## Configuration
+
+The recommended configuration is the global plugin entry shown above (with
+the npm package name):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@darknesskiller/opencode-cliproxyapi",
+      {
+        "baseURL": "http://your-server:8317",
+        "apiKey": "your-cli-proxy-api-key",
+        "providerName": "My CLIProxyAPI"
+      }
+    ]
+  ]
+}
+```
+
+| Plugin option | Default | Purpose |
+| --- | --- | --- |
+| `baseURL` | `CLIPROXY_BASE_URL` or `http://localhost:8317/v1` | CLIProxyAPI URL |
+| `apiKey` | `CLIPROXY_API_KEY` | CLIProxyAPI key |
+| `providerID` | `cliproxyapi` | ID used in `provider/model` names |
+| `providerName` | `CLIProxyAPI` | Name displayed in the model picker |
+| `protocol` | `chat` | Default protocol: `chat` uses `/chat/completions`; `responses` uses `/responses`. Models marked as Anthropic-compatible by dynamic metadata override this per model. |
+| `modelMetadataURL` | `https://models.dev/api.json` | Dynamic model-level protocol metadata. Set to `false` to disable enrichment and use only the default protocol. |
+| `discoveryTimeoutMs` | `10000` | Startup model-discovery timeout |
+
+If model metadata cannot be reached, the plugin logs a warning and keeps the
+CLIProxyAPI-discovered models available with the configured default protocol.
+
+### Optional environment variables
+
+Environment variables remain available for containers, CI, or users who prefer
+not to place a key in the config:
+
+```bash
+export CLIPROXY_BASE_URL="http://your-server:8317"
+export CLIPROXY_API_KEY="your-cli-proxy-api-key"
+```
+
+Put these lines in your shell profile if you want them to persist. Explicit
+plugin options in `opencode.json` take precedence over environment variables.
+
+Existing `provider.cliproxyapi` settings are preserved, so individual models
+can be customized:
+
+```json
+{
+  "provider": {
+    "cliproxyapi": {
+      "models": {
+        "gpt-5.6-terra": {
+          "name": "Terra",
+          "limit": {
+            "context": 200000,
+            "output": 65536
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## Troubleshooting
+
+### `Missing API key`
+
+Check that the global plugin entry contains a non-empty `apiKey`, then restart
+OpenCode. If you chose environment variables instead, ensure
+`CLIPROXY_API_KEY` is available to the process that starts OpenCode.
+
+### No CLIProxyAPI models appear
+
+First check the API directly:
+
+```bash
+curl -H "Authorization: Bearer your-cli-proxy-api-key" \
+  "http://your-server:8317/v1/models"
+```
+
+Then restart OpenCode and run:
+
+```bash
+opencode models cliproxyapi
+```
+
+### Environment configuration works in one terminal but not another
+
+Move the connection to the recommended global OpenCode config, or add the
+environment variables to your shell profile.
+
+### The plugin does not load after updating
+
+Restart OpenCode so it picks up the newest published version of the npm
+package. If the package was never installed, check that the name in the
+`plugin` list is exactly `@darknesskiller/opencode-cliproxyapi` and that you
+are not also loading the original `opencode-cliproxyapi` package (both
+register the same `cliproxyapi` provider).
+
+## Development
+
+```bash
+git clone https://github.com/DarknessKiller/opencode-cliproxyapi.git
+cd opencode-cliproxyapi
+bun install
+bun run check
+```
+
+The repository's `opencode.json` loads the local build for integration testing:
+
+```bash
+bun run build
+export CLIPROXY_BASE_URL="http://your-server:8317"
+export CLIPROXY_API_KEY="your-cli-proxy-api-key"
+opencode models cliproxyapi
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for contribution guidelines and
+[SECURITY.md](SECURITY.md) for private vulnerability reporting.
+
+## License
+
+[MIT](LICENSE)

package/dist/catalog.d.ts

@@ -0,0 +1,35 @@
+export type CatalogModel = {
+    id: string;
+    ownedBy?: string;
+};
+export type ModelProtocolCatalog = Record<string, {
+    npm?: string;
+    models: Record<string, string>;
+}>;
+export type ReasoningEffortLevels = {
+    levels: string[];
+    defaultLevel?: string;
+};
+export type ReasoningEffortCatalog = Record<string, ReasoningEffortLevels>;
+export declare function normalizeBaseURL(value: string): string;
+export declare function parseCatalog(input: unknown): CatalogModel[];
+export declare function parseReasoningEffortCatalog(input: unknown): ReasoningEffortCatalog;
+export declare function discoverReasoningEfforts(input: {
+    baseURL: string;
+    apiKey?: string;
+    timeoutMs: number;
+    fetcher?: typeof fetch;
+}): Promise<ReasoningEffortCatalog>;
+export declare function discoverModels(input: {
+    baseURL: string;
+    apiKey?: string;
+    timeoutMs: number;
+    fetcher?: typeof fetch;
+}): Promise<CatalogModel[]>;
+export declare function parseModelProtocolCatalog(input: unknown): ModelProtocolCatalog;
+export declare function discoverModelProtocols(input: {
+    url: string;
+    timeoutMs: number;
+    fetcher?: typeof fetch;
+}): Promise<ModelProtocolCatalog>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC,MAAM,EACN;IACE,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B,CACF,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAGD,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAA;AAW1E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,UAK7C;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,EAAE,CAuB3D;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,sBAAsB,CAqBlF;AAED,wBAAsB,wBAAwB,CAAC,KAAK,EAAE;IACpD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;CACvB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAiBlC;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;CACvB,2BAcA;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,CAsB9E;AAED,wBAAsB,sBAAsB,CAAC,KAAK,EAAE;IAClD,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,KAAK,CAAA;CACvB,iCAaA"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const CLIProxyAPIPlugin: Plugin;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;
+export { discoverModelProtocols, discoverModels, discoverReasoningEfforts, normalizeBaseURL, parseCatalog, parseModelProtocolCatalog, parseReasoningEffortCatalog, } from "./catalog.js";
+export type { CatalogModel, ModelProtocolCatalog, ReasoningEffortCatalog } from "./catalog.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,MAAM,EAA+B,MAAM,qBAAqB,CAAA;AAkCtF,eAAO,MAAM,iBAAiB,EAAE,MA8E/B,CAAA;;;;;AAED,wBAGwB;AACxB,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,gBAAgB,EAChB,YAAY,EACZ,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,320 @@
+// @bun
+// src/catalog.ts
+var REASONING_LEVELS_CLIENT_VERSION = "1.0.0";
+function normalizeBaseURL(value) {
+  const url = new URL(value);
+  const pathname = url.pathname.replace(/\/+$/, "");
+  url.pathname = pathname.endsWith("/v1") ? pathname : `${pathname}/v1`;
+  return url.toString().replace(/\/$/, "");
+}
+function parseCatalog(input) {
+  if (!isRecord(input))
+    throw new Error("CLIProxyAPI returned a non-object model catalog");
+  const response = input;
+  if (!Array.isArray(response.data))
+    throw new Error("CLIProxyAPI model catalog is missing the data array");
+  const models = response.data.map((item) => {
+    if (!isRecord(item) || typeof item.id !== "string" || item.id.trim() === "")
+      return;
+    return {
+      id: item.id,
+      ...typeof item.owned_by === "string" ? { ownedBy: item.owned_by } : {}
+    };
+  }).filter((item) => item !== undefined);
+  if (models.length === 0)
+    throw new Error("CLIProxyAPI returned no usable models");
+  const unique = new Map;
+  for (const model of models) {
+    if (!unique.has(model.id))
+      unique.set(model.id, model);
+  }
+  return [...unique.values()];
+}
+function parseReasoningEffortCatalog(input) {
+  if (!isRecord(input) || !Array.isArray(input.models))
+    return {};
+  const catalog = {};
+  for (const item of input.models) {
+    if (!isRecord(item) || typeof item.slug !== "string" || item.slug.trim() === "")
+      continue;
+    const rawLevels = item.supported_reasoning_levels;
+    if (!Array.isArray(rawLevels))
+      continue;
+    const levels = rawLevels.map((entry) => isRecord(entry) && typeof entry.effort === "string" ? entry.effort : undefined).filter((level) => level !== undefined);
+    if (levels.length === 0)
+      continue;
+    const defaultLevel = typeof item.default_reasoning_level === "string" ? item.default_reasoning_level : undefined;
+    catalog[item.slug] = {
+      levels: [...new Set(levels)],
+      ...defaultLevel ? { defaultLevel } : {}
+    };
+  }
+  return catalog;
+}
+async function discoverReasoningEfforts(input) {
+  const response = await (input.fetcher ?? fetch)(`${input.baseURL}/models?client_version=${REASONING_LEVELS_CLIENT_VERSION}`, {
+    headers: input.apiKey ? { Authorization: `Bearer ${input.apiKey}` } : undefined,
+    signal: AbortSignal.timeout(input.timeoutMs)
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim().slice(0, 300);
+    throw new Error(`CLIProxyAPI reasoning-level discovery failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+  return parseReasoningEffortCatalog(await response.json());
+}
+async function discoverModels(input) {
+  const response = await (input.fetcher ?? fetch)(`${input.baseURL}/models`, {
+    headers: input.apiKey ? { Authorization: `Bearer ${input.apiKey}` } : undefined,
+    signal: AbortSignal.timeout(input.timeoutMs)
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim().slice(0, 300);
+    throw new Error(`CLIProxyAPI model discovery failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+  return parseCatalog(await response.json());
+}
+function parseModelProtocolCatalog(input) {
+  if (!isRecord(input))
+    throw new Error("Model metadata service returned a non-object catalog");
+  return Object.fromEntries(Object.entries(input).flatMap(([providerID, provider]) => {
+    if (!isRecord(provider))
+      return [];
+    const models = Object.fromEntries(Object.entries(isRecord(provider.models) ? provider.models : {}).flatMap(([modelID, model]) => {
+      if (!isRecord(model) || !isRecord(model.provider) || typeof model.provider.npm !== "string") {
+        return [];
+      }
+      return [[modelID, model.provider.npm]];
+    }));
+    const npm = typeof provider.npm === "string" ? provider.npm : undefined;
+    return npm || Object.keys(models).length > 0 ? [[providerID, { ...npm ? { npm } : {}, models }]] : [];
+  }));
+}
+async function discoverModelProtocols(input) {
+  const response = await (input.fetcher ?? fetch)(input.url, {
+    signal: AbortSignal.timeout(input.timeoutMs)
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim().slice(0, 300);
+    throw new Error(`Model protocol discovery failed with HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+  }
+  return parseModelProtocolCatalog(await response.json());
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/index.ts
+var DEFAULT_BASE_URL = "http://localhost:8317/v1";
+var DEFAULT_PROVIDER_ID = "cliproxyapi";
+var DEFAULT_PROVIDER_NAME = "CLIProxyAPI";
+var DEFAULT_DISCOVERY_TIMEOUT_MS = 1e4;
+var DEFAULT_MODEL_METADATA_URL = "https://models.dev/api.json";
+var CLIProxyAPIPlugin = async ({ client }, rawOptions) => {
+  const options = readOptions(rawOptions);
+  return {
+    config: async (config) => {
+      const providerID = options.providerID ?? DEFAULT_PROVIDER_ID;
+      const existing = config.provider?.[providerID];
+      const baseURL = normalizeBaseURL(options.baseURL ?? process.env.CLIPROXY_BASE_URL ?? stringOption(existing?.options?.baseURL) ?? DEFAULT_BASE_URL);
+      const apiKey = options.apiKey ?? process.env.CLIPROXY_API_KEY ?? stringOption(existing?.options?.apiKey);
+      try {
+        const timeoutMs = options.discoveryTimeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
+        const [catalog, protocolDiscovery, effortDiscovery] = await Promise.all([
+          discoverModels({
+            baseURL,
+            apiKey,
+            timeoutMs
+          }),
+          discoverProtocols({
+            url: options.modelMetadataURL ?? DEFAULT_MODEL_METADATA_URL,
+            timeoutMs
+          }),
+          discoverEffortLevels({
+            baseURL,
+            apiKey,
+            timeoutMs
+          })
+        ]);
+        const discoveryErrors = [protocolDiscovery.error, effortDiscovery.error].filter((error) => error !== undefined);
+        for (const message of discoveryErrors) {
+          await client.app.log({
+            body: {
+              service: "opencode-cliproxyapi",
+              level: "warn",
+              message
+            }
+          });
+        }
+        addProvider(config, {
+          providerID,
+          providerName: options.providerName ?? DEFAULT_PROVIDER_NAME,
+          baseURL,
+          apiKey,
+          protocol: options.protocol ?? "chat",
+          catalog,
+          protocolCatalog: protocolDiscovery.catalog,
+          effortCatalog: effortDiscovery.catalog
+        });
+        await client.app.log({
+          body: {
+            service: "opencode-cliproxyapi",
+            level: "info",
+            message: `Discovered ${catalog.length} CLIProxyAPI models from ${baseURL}`
+          }
+        });
+      } catch (error) {
+        await client.app.log({
+          body: {
+            service: "opencode-cliproxyapi",
+            level: "error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+        throw error;
+      }
+    }
+  };
+};
+var src_default = {
+  id: "opencode-cliproxyapi",
+  server: CLIProxyAPIPlugin
+};
+function addProvider(config, input) {
+  const existing = config.provider?.[input.providerID];
+  const discovered = Object.fromEntries(input.catalog.map((model) => [
+    model.id,
+    {
+      name: displayName(model.id),
+      tool_call: !isImageModel(model.id),
+      reasoning: isReasoningModel(model.id, input.effortCatalog[model.id]),
+      attachment: supportsAttachments(model.id),
+      ...model.ownedBy && resolveModelNpm(input.protocolCatalog, model.ownedBy, model.id) === "@ai-sdk/anthropic" ? {
+        provider: {
+          npm: "@ai-sdk/anthropic"
+        }
+      } : {},
+      ...isImageModel(model.id) ? {
+        modalities: {
+          input: ["text", "image"],
+          output: ["image"]
+        }
+      } : {},
+      ...reasoningEffortConfig(model, input)
+    }
+  ]));
+  config.provider = {
+    ...config.provider,
+    [input.providerID]: {
+      ...existing,
+      name: existing?.name ?? input.providerName,
+      npm: existing?.npm ?? (input.protocol === "responses" ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible"),
+      env: [...new Set([...existing?.env ?? [], "CLIPROXY_API_KEY"])],
+      options: {
+        ...existing?.options,
+        baseURL: input.baseURL,
+        ...input.apiKey ? { apiKey: input.apiKey } : {}
+      },
+      models: mergeModels(discovered, existing?.models)
+    }
+  };
+}
+function reasoningEffortConfig(model, input) {
+  const efforts = input.effortCatalog[model.id];
+  if (!efforts)
+    return {};
+  const anthropicRouted = model.ownedBy !== undefined && resolveModelNpm(input.protocolCatalog, model.ownedBy, model.id) === "@ai-sdk/anthropic";
+  if (anthropicRouted)
+    return {};
+  const levels = efforts.levels.filter((level) => level !== "none");
+  if (levels.length === 0)
+    return {};
+  const defaultLevel = efforts.defaultLevel !== undefined && efforts.levels.includes(efforts.defaultLevel) ? efforts.defaultLevel : undefined;
+  return {
+    ...defaultLevel ? { options: { reasoningEffort: defaultLevel } } : {},
+    variants: Object.fromEntries(levels.map((level) => [level, { reasoningEffort: level }]))
+  };
+}
+function resolveModelNpm(catalog, providerID, modelID) {
+  const provider = catalog[providerID];
+  return provider?.models[modelID] ?? provider?.npm;
+}
+function mergeModels(discovered, existing) {
+  const merged = { ...discovered };
+  for (const [modelID, model] of Object.entries(existing ?? {})) {
+    const discoveredModel = merged[modelID];
+    const providerNpm = model.provider?.npm ?? discoveredModel?.provider?.npm;
+    merged[modelID] = {
+      ...discoveredModel,
+      ...model,
+      ...providerNpm ? { provider: { npm: providerNpm } } : {}
+    };
+  }
+  return merged;
+}
+function readOptions(input) {
+  if (!input)
+    return {};
+  return {
+    baseURL: stringOption(input.baseURL),
+    apiKey: stringOption(input.apiKey),
+    providerID: stringOption(input.providerID),
+    providerName: stringOption(input.providerName),
+    protocol: input.protocol === "responses" ? "responses" : input.protocol === "chat" ? "chat" : undefined,
+    modelMetadataURL: input.modelMetadataURL === false ? false : stringOption(input.modelMetadataURL),
+    discoveryTimeoutMs: typeof input.discoveryTimeoutMs === "number" && input.discoveryTimeoutMs > 0 ? input.discoveryTimeoutMs : undefined
+  };
+}
+function discoverProtocols(input) {
+  if (input.url === false)
+    return Promise.resolve({ catalog: {} });
+  return discoverModelProtocols({
+    url: input.url,
+    timeoutMs: input.timeoutMs
+  }).then((catalog) => ({ catalog })).catch((error) => ({
+    catalog: {},
+    error: error instanceof Error ? error.message : String(error)
+  }));
+}
+function discoverEffortLevels(input) {
+  return discoverReasoningEfforts(input).then((catalog) => ({ catalog })).catch((error) => ({
+    catalog: {},
+    error: error instanceof Error ? error.message : String(error)
+  }));
+}
+function stringOption(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function displayName(modelID) {
+  return modelID.split("-").map((part) => {
+    const lower = part.toLowerCase();
+    if (lower === "gpt")
+      return "GPT";
+    if (lower === "oss")
+      return "OSS";
+    if (lower === "codex")
+      return "Codex";
+    return part.charAt(0).toUpperCase() + part.slice(1);
+  }).join(" ");
+}
+function isImageModel(modelID) {
+  return /(?:^|-)image(?:-|$)/i.test(modelID);
+}
+function isReasoningModel(modelID, efforts) {
+  if (efforts?.levels.length)
+    return efforts.levels.some((level) => level !== "none");
+  return /thinking|reasoning|codex|gpt-(?:5|oss)/i.test(modelID);
+}
+function supportsAttachments(modelID) {
+  return /^(?:claude|gemini|gpt)/i.test(modelID);
+}
+export {
+  CLIProxyAPIPlugin,
+  src_default as default,
+  discoverModelProtocols,
+  discoverModels,
+  discoverReasoningEfforts,
+  normalizeBaseURL,
+  parseCatalog,
+  parseModelProtocolCatalog,
+  parseReasoningEffortCatalog
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@darknesskiller/opencode-cliproxyapi",
+  "version": "0.2.0",
+  "description": "Fork of opencode-cliproxyapi that discovers CLIProxyAPI models and auto-configures reasoning-effort variants in OpenCode.",
+  "type": "module",
+  "license": "MIT",
+  "author": "İbrahim BABAL",
+  "homepage": "https://github.com/DarknessKiller/opencode-cliproxyapi#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DarknessKiller/opencode-cliproxyapi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/DarknessKiller/opencode-cliproxyapi/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --format esm --external @opencode-ai/plugin && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test ./src",
+    "check": "bun run typecheck && bun run test && bun run build",
+    "prepublishOnly": "bun run check"
+  },
+  "keywords": [
+    "opencode",
+    "cliproxyapi",
+    "llm",
+    "plugin"
+  ],
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.18.29",
+    "@types/bun": "^1.3.5",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}