Awesome DeepSeek Harness Plugin

ChatGPT OAuth provider for Codex models with subscription web search, quota and safe reset, image tools, Fast mode, and model-aware context; no API key or Codex CLI.

Connect ChatGPT OAuth and OpenAI Codex models to DeepSeek Harness, with opt-in search and image tools.

Unofficial Command Code LLM provider: registers a `commandcode` route with a live model catalog and reasoning-effort support.

Registers ChatGPT Codex, Claude, Grok and Antigravity subscriptions as DeepSeek Harness LLM providers through OAuth, so no API key is needed for them.

Use ChatGPT (Codex), Claude, and Grok subscriptions as DeepSeek Harness LLM providers, with Settings login, model catalogs, usage, plus image_generate, video_generate, and x_search tools.

Compact Codex coding mode for DSH: light prompt guardrails against GPT over-explaining, with an editable prompt and native Codex-style tools.

Brings the models in the WorkBuddy desktop app straight into DeepSeek Harness — zero configuration in the DSH chat.

Keeps a pool of API keys per provider with auto-created clone routes, switches to the next key on quota or rate-limit errors, probes cooled keys for recovery, and exposes the pools, cooldown and switch codes in a Settings section.

Configure reasoning-effort levels and sub-agent defaults for custom DSH models.

Coding-subscription OAuth for SuperGrok/Grok Build, ChatGPT Plus Codex, Kimi Code and Claude Code, plus an opt-in loopback OpenAI/Anthropic gateway: local login without pasting tokens, AUTH refresh-and-retry, grok-4.6 xhigh, and API-key route coexistence.

Connects locally signed-in WorkBuddy models to DSH, supports per-model image input opt-in, account switching, and a read-only credits overview with daily check-in.

ClineBot and ClinePass integration for DeepSeek Harness: dedicated settings page, live quota dashboard, in-UI key saving, curated and custom model selection, and a /cline command.

Per-model reasoning-effort and input-modality configuration for third-party providers: suggestions fused from a model knowledge base and raw /models endpoint evidence with confidence labels, edited inside the official Models page card.

Qwen Token Plan CN Responses provider for DeepSeek Harness via the OpenAI Responses API, with Qwen server-side tools, DSH local function tools, text/reasoning/tool-call multi-turn history, persisted image attachments, and a per-release official model catalog snapshot.

Per-round thinking-level (reasoning_effort) control for DeepSeek Harness: pick Auto and it schedules low/high/max from the recent tool-call history, or fix a wire level (off/on/minimal/low/medium/high/xhigh/max) manually, with custom wire mapping, a model-aware capability guard, and context-window presets (64K–1M); its per-model capability card pairs with a separate plugin, [dsh-llm-openai-completions](https://github.com/drscrewdriver/dsh-llm-openai-completions) (installable from dsh-market), so custom OpenAI-compatible gateways (vLLM / LM Studio / self-hosted) can try reasoning — the card writes llm-pi-ai capabilities, the adapter drives the wire (compat.thinkingFormat), and this plugin auto-maintains the takeover list.

Google Antigravity (agy CLI) models for DSH — streaming chat with Gemini/Claude/GPT-OSS subscriptions, native tool cards, thinking turns, and in-GUI Google OAuth login.

Attaches a stable per-conversation x-opencode-session header to OpenCode / OpenCode Go provider requests, fixing 400 MissingSessionID errors and keeping session affinity and prompt-cache routing intact.

Connects locally signed-in Trae CN models to DSH, supports DSH-executed tool calls, account switching, and Work/general credit visibility.

An AI routing gateway that runs as a DSH plugin. Adds a Routing System sidebar panel for suppliers, account pool, fallback combos and API keys, and serves an OpenAI-compatible endpoint at http://localhost:3080/v1.

Synchronizes the model catalog of API-key providers from the provider itself instead of maintaining the model list by hand.

Ollama provider for DeepSeek Harness with model management, health checks, rule-based local routing, and cloud fallback.

Role-based LLM retry & fallback strategies.

OpenCode Go provider with live gateway model discovery, online models.dev capability metadata, session routing, and Web settings with subscription usage.

Exposes OpenCode Zen free models to DeepSeek Harness, with no API key.

Merge every locally signed-in WorkBuddy account into DeepSeek Harness as one auto-failing-over model pool (multi-account rotation, live credits, and a model catalog showing per-model credit multipliers and free/night-discount tags).

Grok Build provider using the official CLI browser login, with dynamic account-visible models, streaming reasoning and tools, plus quota and model-capability settings.

Measures what an llm-pi-ai endpoint really accepts — context window from its own model list, output-token limit and reasoning levels read out of its own range errors, image support from a generated test image — then reports declared values that contradict that evidence and rewrites them only after confirmation.

Session-affinity routing for LLM gateways: injects the session ID into every request sent to NewApi-style gateways so the gateway can pin requests per session and raise prompt-cache hits; takes over the official pi-ai routing on install and restores it on uninstall.

Configurable default model for subagent delegations via settings.yaml, with single-model and multi-model round-robin or random strategies.

Per-subagent LLM provider/model selection with role templates.

CodeBuddy supplier plugin for dsh-router. Handles one account at a time with polling OAuth login and token refresh, leaving account selection, cooldown and check-in to dsh-router core.

Reuses the CodeBuddy CLI sign-in to bring its models into DeepSeek Harness, with a settings card showing account, token expiry, and remaining credit.

Model capability editor: edit each model reasoning-effort levels and image-input (multimodal) declarations inline in the official model page, written back to settings.yaml as a whole group, with a floating entry as fallback when the anchor breaks.

Three independent language channels for model output — tool-call descriptions (every tool-call card title, including run_code in PTC-style presets), thinking, and replies — each set to follow the web GUI language, force a specific language, or turn off (default: only descriptions, following the GUI). One global runtime-context prompt directive on the host; the client half reports the GUI language; a Settings plugin card switches the modes.

Automatic model-tier routing for DeepSeek Harness: one user instruction enters, one tier decision comes out — complex intent is planned on the strong tier and implemented on the cheap tier, simple intent stays cheap throughout, with a deterministic guard and a TTL escalation fallback.

Community Codex provider for DeepSeek Harness with ChatGPT OAuth, Codex models, image input, quota display, per-session Fast and transport controls, and safe stream recovery.

Models+ settings page for the DSH web UI: per-model reasoning-effort tables, input modalities and compat flags saved through the official settings pipeline, with models.dev metadata prefill and API key management.

Displays CodexRadar model capability benchmarks in a Settings page and shows the selected session model's DeepSWE score beside the composer.

Provides an OAuth account page for DSH Web, currently supporting OpenAI Codex, GitHub Copilot, Anthropic, Kimi For Coding, OpenRouter, and xAI.

Model Health panel in Settings: lists every model configured in settings.yaml and batch-tests availability and latency for each.

Claude Code CLI as an LLM provider for dsh: live model list, per-session resume, approval relay, images, a memory/rewind/changes panel, and workspaces on remote SSH boxes.

TRAE SOLO supplier plugin for dsh-router, ported from traework2api. Provides the traework supplier, a free SOLO chat channel, and reports single-account status to dsh-router core.

Reuses the Codex CLI ChatGPT login as an `openai-codex` LLM route and adds GPT Auth controls to DSH Web settings.

Configures provider and model reasoning-effort mappings for DeepSeek Harness, with a grouped model picker and composer slider.

Route OpenRouter requests through a configured provider list and quantization cap, injected as provider.only/order with allow_fallbacks, plus provider.quantizations.

Early-stage plugin connecting DeepSeek Harness to a separately deployed, self-hosted OwnDsh server for team identity, model access control, quotas, and usage auditing.

Model Capability Manager for DSH Web: thinking levels, context window, output caps, input modalities, gateway compat presets, EN/中文 UI.

Adds an unofficial Antigravity OAuth-backed LLM route, web search, image generation and editing, video understanding, quota status, and DSH Web settings controls.

GitHub Copilot LLM adapter: OAuth device-flow sign-in, live model discovery from the Copilot API, vision support for image-capable models (gpt-4.1, gpt-4o), and two wire protocols (Chat Completions and Responses API) with automatic endpoint routing per model.

Fills in what the official pi-ai adapter leaves out on the Models page: gateway reachability probing with latency, one-click pull of the gateway model catalog with checkbox write-back into settings, DeepSeek balance and provider quota shown in place, the protocol and endpoint each provider is actually wired to, and a model dropdown that lists only what works right now — a dead key, an empty balance or an exhausted quota is hidden until you fix it, and comes back on its own.

One-click OpenAI-compatible API (CodeBuddy/vLLM/proxies) with thinking mode, avoiding developer-role content_filter rejection.

Connects Qoder subscriptions to DeepSeek Harness, supporting Global and China regions, multimodal input, and tool calls.

Search and select models in the DeepSeek Harness WebUI with a native settings card.

File-defined subagent roles for DeepSeek Harness: roles live in project and global .dsh/roles files, a delegating agent sees one catalog line per role, and each role's tool policy decides which tools its child can see.

Adds a deepseek-web provider that uses chat.deepseek.com web models in DSH, with browser login capture, PoW request signing, SSE streaming, and prompting-based tool calls.

Settings card for the DSH LLM auto-retry engine: tune retry count, backoff and jitter live from Settings -> General, with configurable retryableCodes chips - defaults add INVALID_REQUEST so OpenAI-style HTTP 400 reasoning_text errors in thinking mode get retried automatically.

Add missing reasoning-effort declarations to custom pi-ai models through DSH settings, enabling the native effort picker and handling models added later.

Connect Google Antigravity Code Assist OAuth accounts to DeepSeek Harness for Gemini and Claude streaming LLM routing and Nano Banana 2 image generation.

Tencent CodeBuddy model provider for DeepSeek Harness that signs in with browser OAuth instead of an API key, lists the CodeBuddy model catalog with the context, output, tool-calling, reasoning and image capabilities of each model, keeps multiple accounts with automatic failover to the next usable one, shows remaining quota in the composer with a token and credit usage panel, and completes automatable CodeBuddy growth tasks per account with an execution log. Install from npm with `dsh plugin --profile web add @tnnevol/dsh-codebuddy`.

Model pricing for the DSH settings page: ~7,250 models / 213 providers with the harness catalog overlaid, honest lowest-listed comparison, session costs priced by the actual route, cache-leak attribution, and a verified promotion feed.

Peak / off-peak rate badges for the model selector (every row) and the composer tool row, judged per provider by its own time zone and schedule; the live catalog is served from the host over a fenced route.

Codex-shaped coding tools and agent presets for GPT models on DeepSeek Harness: exec_command, write_stdin, apply_patch and view_image, plus OpenAI Chat Completions and Responses API routes, bridged to DSH-native plan, ask, approval and compaction. Long-running commands become DSH background jobs with bounded head/tail output readable through job_output, and each subagent type can be pinned to its own preset, provider, model and reasoning effort.

Per-model proxy routing for LLM requests: selected models go through a proxy (Clash etc.) while the rest stay direct, with automatic retry on transport errors, 429 and 5xx, configured live from the settings page.

Routes agent requests to configurable default, planner, and subagent models, automatically using the planner role in plan mode, with per-role reasoning effort and Web UI configuration.

LLM adapter plugin for locally deployed Qwen models behind a vLLM OpenAI-compatible endpoint, with per-model multimodal switch, fully configurable reasoning efforts, and a web settings page for editing the deployment from the frontend.

Free conversational ChatGPT Web (GPT 5.6 Luna) model provider for DeepSeek Harness with streaming Markdown.

Volcengine Ark Coding Plan LLM provider for DeepSeek Harness: provider-scoped PDF and image input, with Responses API streaming support.

Automatic Flash/Pro routing for DeepSeek Harness subagent calls: light tasks run on a cheap model (e.g. V4 Flash), heavy tasks stay on the strong model — with per-call overrides and /delegate session modes.

Compliantly use your own Antigravity quota in dsh: bridges your local logged-in official Antigravity CLI (agy) session as the chat and subagent model provider.

Ranks OpenRouter providers for the current DSH model by quantization, speed, cache-heavy price, context, and uptime, with one-click switching to help reduce token costs.

Unofficial FreeCodeGo for DeepSeek Harness: a managed free-model gateway and provider catalogs, image and video generation behind one settings switch, DeepSeek/Codex/Claude engine routing, an independent advisor reviewer, code review, code graphs, project memory, and an engineering team toolchain.

Keeps long DSH sessions alive when a model channel starts failing: daruma takes over after the in-box retry gives up, trips a self-healing circuit breaker on repeated 429/5xx or a terminal error, and moves the next request to another channel in your chain. A panel beside the composer picks the backup by hand, switches show up as rows in the conversation, and every decision lands in a durable JSONL audit log.

Wraps globalThis.fetch to route DeepSeek Harness model-API requests through an HTTP/SOCKS proxy by target domain, leaving all other requests on the direct connection, without modifying Harness source.

Declares per-model reasoning-effort ladders for third-party providers in the llm-pi-ai settings section, so DSH's stock thinking-intensity selector works on models the pi-ai catalog does not describe.

Unofficial Grok integration for eligible SuperGrok or X Premium subscriptions: grok-4.6 chat with main-loop web/X search, shared Grok CLI OAuth, configurable model visibility, and Imagine images saved to an attachment or chosen path.

Adds ChatGPT/Codex OAuth-backed Codex models and gpt-image-2 generation/editing to DSH without requiring an OpenAI Platform API key.

Per-model system prompt injector for DeepSeek Harness: append custom prompt text to the END of the system prompt for locally configured models, matched by exact provider/model route or a provider-wide provider/* rule (both stack in order). A Settings page lists every configured provider and its models for per-route editing with instant effect, and rules persist to DSH_HOME so they survive restarts. Applies to main sessions, subagents, and workflow children alike.

Detects which conversation model an account is being served: launches concurrent throwaway probe conversations, scores each streaming chain-of-thought by how its paragraphs open, and cancels probes that read as the older model within seconds. Includes an offline self-check that replays 13 hand-labelled chains-of-thought through the same classifier.

Lifecycle management UI for the llm-pi-ai model provider: create, edit, delete, enable and disable providers with custom headers and AES-GCM-encrypted API keys; uninstall-safe restore of parked providers, remote model discovery with batch write, smart routing with five strategies, union/intersection composites, per-model connectivity tests, and request observability.

Configure the contextWindow for models registered in dsh, so long sessions are no longer misjudged as context overflow.

Unified model routing for DeepSeek Harness: one logical ModelID over multiple providers with first-token failover and cooldown, health-aware candidate ranking, three tiers (tier1/tier2/tier3) auto-selected by purpose, per-candidate reasoning effort, and a settings-page management panel.

Connect a sub2api gateway to DeepSeek Harness: OpenAI-compatible multi-provider routes (OpenAI / Claude / Grok / Gemini) behind one base URL, with per-key model discovery, usage lookup, and global vision/image tools.

Modellix integration for DSH: schema-driven image, video and audio generation in a split Design workspace, a live LLM model catalog, and native web search and fetch providers through one API key.

Registers the Xunfei Loomy cloud channel as an OpenAI-compatible supplier in dsh-router, adding model listing and streaming chat completions.

Single-model disable gate: hides denied models from DSH catalogs, blocks direct dispatch with an in-protocol error chunk, and exposes a settings UI for the denylist.

Registers Ark Agent Plan, Coding Plan and postpaid model routes in the native DSH model picker.

Groups the model picker by provider: the menu lists sources first, and each source opens its models in a slide-in side panel (default) or inline below the title, switchable by double-clicking the source title.

Smart subagent routing and evolution: bind roles to any provider/model registered in DSH, including models supplied by Codex and Claude Code provider plugins, with workspace learning.

Reasoning-effort tier manager for custom API models plus cross-session preference memory: inline low/medium/high/max toggles inside Settings → Models, with atomic settings writes.

Multi-model orchestrator: the main brain decomposes complex tasks and dispatches subtasks to GLM / Kimi / Qwen sub-agents by each model's strengths, with per-model token usage.

Connects ChatGPT accounts through OAuth, switches among them manually or automatically, and adds Codex models with usage limits to DeepSeek Harness.

Expose every model already configured in your local DeepSeek Harness to the LAN over OpenAI- and Anthropic-compatible endpoints, with API keys, per-key rate limits, a circuit breaker, model filters and usage reports.

Sign in to an xAI Grok subscription with device-code OAuth, refresh the access token, and use it as the xai route credential without an API key.

Writes live provider model lists into DSH settings and shows 5h/7d plan windows or metered balance for the current session model.

Replaces the official Models settings page with provider lifecycle management, per-model reasoning effort tiers, retry overrides, drag reorder and upstream model sync.

Adds Claude, Gemini, and a local Ollama model to DSH's native model picker, using your existing Claude Code / Antigravity CLI logins instead of a metered API key, with a working reasoning-effort selector for Claude.

OpenRouter provider that reads the live /models list, so new models appear without a harness release: models sorted by name with input/output prices, per-model reasoning levels, image input, reasoning_details replay, Anthropic prompt caching, and actual spend per session including subagents from OpenRouter usage.cost, shown under the Web UI composer and by /cost.

Adds the KnyazevAI API provider and its DeepSeek, GLM, and MiniMax model catalog to DeepSeek Harness.

Adds Token Market as an OpenAI-compatible model provider with DeepSeek V4 Pro, Kimi K3, and GLM-5.3.

Adds an input-modality selector to custom model settings in the DeepSeek Harness Web UI.

Serves the live opencode Go model catalog from the harness's built-in opencode-go provider route.

Google Antigravity / Cloud Code Assist model provider with quota management and model selector.

Use a ChatGPT/Codex subscription in DeepSeek Harness with GPT models, image generation, web search, subscription quota reporting, model and feature controls, and browser or device-code OAuth sign-in.

Brings the models included in the Xiaomi MiMo desktop app (free during beta) into DeepSeek Harness, with zero configuration in the DSH conversation window.

Pools several OpenCode Go API keys and hot-switches each request to the least-used one, with official usage and balance lookup plus a graphical settings page.

Free model provider plugin for DSH with 20+ models including Gemini, MiMo, GLM, etc.

Codex App Server model provider using a local Codex login, with session reuse, Harness tool bridging, native action traces, and durable generated-image projection.

Weak-network adaptor: transparent long-backoff model-stream retries (10-min cap), local response replay cache, heartbeat auto-reconnect, and degraded-mode token economy, with a bilingual (zh/en) settings page.

Registers Kimi, Grok, Codex, and MiniMax as DeepSeek Harness model routes, vendor subagent recipes, and kernel_status / kernel_run / kernel_switch tools.

Automatic provider failover on rate limits or quota exhaustion: switch between providers with configurable per-provider models, a cooldown, and a permanent last-entry fallback.

DIT.ai provider bundle for DeepSeek Harness: installs 29 OpenAI Chat Completions models and 10 Anthropic Messages models from one DIT_API_KEY, with protocol-specific thinking configuration.

Manages the default DSH model, provider and model visibility, and optional OpenAI Responses web search.

Compaction fix for NInfer-hosted qwen3.8-27b gateways: disables thinking on dsh context-compaction and session-title calls so xhigh reasoning stops burning the whole output budget; the same idea applies to other launch methods, this package targets NInfer only.

Switch the current DSH session's model with a natural-language sentence, on web, TUI, or IM bridges (WeChat, Feishu), without touching the panel.

DSH model provider for the locally authenticated AGY CLI: Gemini/Claude model discovery, independent reasoning effort, DSH-owned tools, bounded context and tool-result handling, and Windows-safe streaming. Report problems in GitHub Issues: https://github.com/darkings/dsh-agy-provider/issues.

GLM Mode agent preset for zhipuai/glm-5.3-flash: PTC/Code Mode tool presentation, a reasoning loop guard and a tool spin guard (live-incident driven), and GLM-specific auto-compaction at 75%/22%.

Model channel manager: several provider/model candidates share one virtual route (roundrobin/<group>) with failover, retry, timeout and cooldown; a settings tab edits providers and groups, runs per-model speed tests and real single-model request tests, and a seven-day health panel aggregates latency, failures and upstream token usage (input, output, cache and reasoning).

Adds a reasoning-level editor with OpenAI and Anthropic protocol presets (llm-pi-ai), input-modality switches and a 1M/128K context and max-output preset to model rows in Settings.

A thinking level stored per provider and model, so reasoning effort outlives the session it was set in and also reaches subagents, which dsh never asks. The in-session picker still wins, and a model with no row keeps its provider default.

Per-model reasoning effort (off/minimal/low/medium/high/xhigh) for GPT, Codex, Gemini and OpenAI-compatible models. Installs a helper, not a runtime adapter: run enable-capabilities.ps1 once per profile (Windows) and restart — it declares the levels in ~/.dsh/settings.yaml, with a disable script and a backup to revert.

Model switching and reasoning-effort control for DeepSeek Harness: set_model and list_models agent tools let the agent autonomously change its provider, model or thinking depth (reasoning effort) mid-task with a mandatory reason, a provider whitelist and a context-window token-pressure guard, the active model is injected into the runtime context, and Plan Mode auto-transition switches to a configured planning model on entering plan mode and restores the previous execution model on exit.

DSH plugin: matches a model you declared on a custom gateway to the capability metadata it should have — context window, output cap, reasoning levels and image support — by looking the bare model name up at runtime; the plugin never writes your settings document.

Per provider/model generation concurrency, with a settings card: a cap on how many sessions may stream at once, enforced at the stream and again at subagent spawn, where a fan-out past the cap waits in a FIFO queue instead of failing.

Sign in with a ChatGPT account and view Codex subscription usage directly in DSH Web's model settings, with browser or device-code OAuth.

Pool AI provider accounts per platform and route them through a local loopback proxy that bridges the OpenAI, OpenAI-Responses, Anthropic and Gemini protocols, then write the proxy into Codex, Claude Code, Gemini CLI, Grok, OpenCode, OpenClaw and Hermes config files with snapshot-and-rollback safe writes; registers no agent tools.

Sets the DeepSeek flash model's reasoning effort per step — thinking off for short cheap prompts, low for a plain request, high for engineering work — and raises it only on repeated tool failures. The model itself never changes; effort max is opt-in.

Adds account login, API and custom Provider setup, model switching, image fallback for text-only models, and token/cost attribution to DeepSeek Harness 47f.

Keeps a local TinyTitan model server reachable from the harness: refreshes the llm-pi-ai route from the installed models and mounts a compaction backend that does not think.

Zero-cost access to 6 free large models. No registration, no recharge, 6 free models built-in, multi-key rotation and rate-limit backoff.

Per-request thinking budgets, a compaction backend, and a settings tab for the local Qwen3.8 line (llama.cpp or NInfer).

Connect a ChatGPT account to Codex models in DeepSeek Harness through browser PKCE or device-code OAuth, with automatic token refresh and Web or headless login.

Automatically and intelligently routes each delegated task to the best configured model using aliases, capability tags, and usage guidance—keeping routine work fast and affordable while sending complex work to stronger specialists. Configure your model team in the Web UI or guided setup, run specialists in parallel with reliable result joining, and see the chosen model at a glance in subagent views and inline in Better Sidebar's Tasks tree.

Global Chinese mode: a compact pill switch beside the composer that injects a language requirement into any preset's system prompt (complete personas excepted); reply, thinking and tool output each toggle between Chinese and English, and anchored presets are supported.

ChatGPT Codex subscription chat: official OAuth, a Sol/Terra/Luna catalog with Fast rows, live usage limits, and optional search and view_image tools.

One-click free-model setup for DSH web, built for coding beginners: one-click installer for Windows (install.bat) and macOS/Linux (install.sh, v1.7.0+); four permanently free channels — Zhipu GLM (text + image), SiliconFlow (Qwen3-8B plus 15+ sub-9B models), iFlytek Spark Lite and the OpenRouter free pool, which routes through openrouter/auto and picks from a pool that changes over time; bottom-left setup hint hides once any free model is connected; real-time DeepSeek peak/off-peak pricing reminder; bundled beginner help center.

Kiro model provider with Builder ID, Identity Center, Google, GitHub and credential-import sign-in, automatic token and profile refresh, account usage, live model discovery, selectable reasoning efforts, streaming tool calls, provider stop-reason and context-overflow handling, and token accounting that uses Kiro's exact counters when it sends them and otherwise scales the context-usage percentage it does send by the model's advertised window.

LLM provider that runs the locally installed Claude Code CLI as the model backend, so requests go through an existing Claude subscription instead of a metered API key; native tool calls are bridged over MCP.

Use third-party subscription accounts in DeepSeek Harness: chat, image understanding, image generation, and image editing with the models your subscription covers, with available models and reasoning levels synced from your account; currently supports OpenAI/ChatGPT subscriptions, more providers planned.

Per-step model router: named presets with ordered image/keyword-group rules route each agent step across every mounted provider and model, adding collaboration flows for image transcription, an image guard, a multi-plan quota panel, and per-step decision observability.

NewAPI (OpenAI-compatible gateway) LLM provider: registers a `newapi` route with chat-only model discovery, auto-fills model parameters (context window, reasoning effort) from models.dev, and adds a Web settings section for the base URL and API key.

Two-tier model routing: a strong tier plans, advises and reviews while a cheap tier implements, with plan-mode-aware auto routing, a high-impact escalation guard, failure auto-escalation, and subagent tiering.

Unofficial upstream bundle for DeepSeek Harness. CodeBuddy gateway with a runtime-synced model catalogue, per-model reasoning efforts, web search/fetch, image generation and a streaming credential bridge, plus TraeWork CN and Qoder CN subscription channels via local translation gateways and a key-type OpenAI-compatible provider registry, all managed from an accordion settings card.

Adds CC Switch providers and models to DeepSeek Harness, with provider filtering and model-name search.

Fills missing context window, max tokens, thinking levels, and image input on custom DSH models from models.dev, and lists unmatched models for manual edits.

Adds models.dev reasoning levels to unconfigured third-party DeepSeek Harness models.

Proactive multi-model scheduling plugin: multi-source signal intake with dedup and urgency ranking, a four-way execute/defer/dismiss/ask-user decision engine, DAG plan generation with parallel model execution, quality reflection with automatic retry and model switch, long-term memory for task patterns and lessons, and strategy evolution via genetic algorithms with sandboxed evaluation and canary rollout.

OpenCode Go subscription chat for DSH with per-model Completions, Responses, or Anthropic protocol selection, model discovery, context, vision and thinking metadata, effort defaults, and usage meters.

Simulates a Codex environment for selected model routes to improve GPT-family model tool-call success.

Deterministic keyword routing, allowlisted model switching, and an isolated image_gen channel for DeepSeek Harness.

Supervises a local workbuddy2api gateway process and exposes its models as an LLM provider, reading context windows and reasoning efforts from the gateway's own model endpoint.

Manages OpenCode Zen free-tier and Go-tier models in settings.yaml — fetches the live model listings from opencode.ai, reports configured-versus-live drift per route, and adds or removes entries through four agent tools and an OpenCode Models settings section.

Adaptive model routing: per-request complexity classification with automatic provider routing.

Hand a DSH web session to the locally installed Claude Code CLI: a per-session engine selector (DSH | Claude Code), Claude models and reasoning effort in the model seat, Claude permission modes in place of the access-mode selector, and permission requests, AskUserQuestion and ExitPlanMode routed to the native DSH approval, question and plan-review cards. The stream is written as native DSH session events, so the built-in transcript, tool cards and nested subagents render it; Claude slash commands merge into the command palette; the CLI is held by a detached broker, so plugin updates and DSH restarts do not interrupt a running turn.

The model switch for DSH: point it at any OpenAI-compatible endpoint, with curated free/cheap DeepSeek provider presets and automatic fallback when a free tier rate-limits you.

Rate-limits LLM requests per provider and per model using a reservation-based token bucket, with queue or reject modes, plus gateway identity rules that rewrite user-agent and inject custom headers.

Import local Codex, Grok, Claude, OpenCode, and CC Switch logins into DSH; pick sources and enable models in Settings.

Command Code Provider API chat for DSH with a Host-held API key, discovered model catalog, effort defaults, an optional zero-data-retention header, quota meters, and per-model OpenAI or Anthropic protocol selection.

Ollama Cloud native chat adapter: direct NDJSON translation of the Ollama /api/chat wire format, model discovery with context windows and capabilities, and web search/fetch providers under the ollama-cloud id, plus a Web settings card.

Sign in to DeepSeek Harness with a Claude Pro/Max membership (no API key), downscale Anthropic request images to a 2000px long edge, slim /compact summarizer payloads, and show 5-hour/weekly plan usage plus DSH message counts.

Connects the locally signed-in WPS Comate desktop account to DeepSeek Harness as a model provider, via a secure loopback shim.

Use your ChatGPT/Codex subscriptions in DSH, with image generation and web search support.

LongCat-2.0 LLM adapter: 1M context, binary thinking mode, tool calling, and streaming over the OpenAI-compatible endpoint.

macOS Keychain credential provider that replaces the local-file provider and uses a signed, notarized universal helper.

Adds a settings page for declaring per-model reasoning efforts and vision support on pi-ai provider routes.

Sub-agent matrix swarm that routes heterogeneous tasks to the most suitable model from an OpenRouter-like gateway plus cfgpu.com/llm/square, dispatches each via in-process subagents or direct LLM calls, and tracks per-model token consumption with a feedback-driven ranking.

Adds OpenAI Codex (ChatGPT) as a selectable DSH provider via the local Codex App Server.

LLM provider adapter that routes model calls through any ACP (Agent Client Protocol) server — Claude Code, Codex, Gemini CLI, Devin and more — with a registry browser, per-server settings UI, lazy authentication, and dynamic model discovery.

Bind your ChatGPT account via official OAuth and chat with ChatGPT models inside DSH, using your Plus/Pro subscription quota.

Pins every request to the native max-effort tier and adds a per-model/per-mode reasoning-depth panel with a 0-20 capability slider, isolated Velocity/Apex profiles, and offline reasoning toolboxes. Distributed as an obfuscated build; commercial use allowed, reverse engineering closed.

Rule-based multi-provider model routing for DeepSeek Harness with pre-first-token failover, cooldown circuit-breaking, usage accounting, and a status API.

Call a new-api (one-api style) relay station's video model from the conversation with @-referenced image/video materials, supporting Seedance 2.0 and Happyhorse text-to-video and image-to-video across four relay protocols.

OpenAI-completions-compatible adapter for custom gateways (vLLM / LM Studio / self-hosted proxies): always role:"system", thinking driven by the model config, Qwen-style response split, and vision-model image input (single / multiple).

Local model plugin for DeepSeek Harness: manage GGUF models in settings, auto-launch llama.cpp on first message, and auto-unload after 5 minutes of idle time to free VRAM.

OpenCode Go subscription models as a DeepSeek Harness provider: re-resolves the live gateway catalog every few minutes, auto-adapts models the built-in table has not seen, and covers streaming, tool calls, image input and subscription usage. A maintained fork of dsh-opencode-go: a clash with the upstream package over the llm-opencode-go settings namespace makes it withdraw quietly instead of failing the whole plugin tree, and an already-claimed opencode-go route makes it serve on opencode-go-plus.

Global Alt+M model command palette for DeepSeek Harness Web: fuzzy search over models and providers, favorites and recents, per-model reasoning effort, provider and model configuration, request retries, capacity presets, and optional OpenRouter image/video generation tools.

Planner/executor delegation with named roles: a strong planner steers, disposable executor sub-agents (per-role routes and prompts) implement. Default role plus per-delegation override, a global reasoning-effort knob in the composer chip, and a settings page for role management.

Tiered model routing for DeepSeek Harness: think/build model tiers, vision delegation (the vision model only describes images; the working model acts), image generation, and a high-impact guard.

Unofficial Cursor subscription chat: Host-owned CLI session login, a displayed model catalog, and subscription usage rails. Cursor staff treat this class of private-client usage as against ToS.

xAI Grok subscription chat: SuperGrok or X Premium+ OAuth, a displayed model subset, Responses through the Grok CLI proxy, and always-on server-side web_search and x_search.

Explicit model routing for Main, Subagents, web_search, and image generation, plus a catalog-driven Composer and Plan Review picker with Model, Effort, Context, Fast, and Thinking variants.

Ranked subagent delegation: role-based model routing with failover, per-route reasoning effort, model-transparent labels, fork delegation, and a visual route editor.

Command Code LLM provider plugin adapted for DSH-Desktop 0.7.1: registers a commandcode route, with a live model catalog, reasoning-effort support, and real-time plan usage display.

Governs multi-model access, monthly credits, manual/quality/credit/auto routing, failure rerouting, and usage auditing for DSH.

Run the main session model on a local Claude Code subscription through the official Claude Agent SDK, taking over the llm/stream route for the claude-code provider, with token-level streaming, session resume, and DSH tools bridged in over MCP so they keep DSH sandbox and approval.

One-click/auto sync provider model lists against /v1/models endpoint.

Replaces the built-in llm-pi-ai and llm-deepseek adapters, the model selector and the Models settings page with self-maintained versions, tracks upstream @earendil-works/pi-ai through a safe-zone download with a one-click enable toggle, and adds provider quota and balance lookups plus a provider management page.

Exposes OpenCode Zen free models to DeepSeek Harness with no API key, tracking Zen gateway changes.

Mirrors cc-switch providers and models into DeepSeek Harness the moment they are saved, and shows each provider's plan windows, account balance, or custom usage script in the composer and the settings card.

Control panel for local LLM inference servers in the DSH web view: service registry with health checks and stop controls, named parameter profiles for llama.cpp, SGLang and vLLM with pre-save KV/VRAM validation, GPU detection, and tok/s benchmarks.

Declare whether a configured third-party model accepts image (multimodal) input; writes the modality into the owning provider settings and verifies it through runtime model resolution.

Declare any number of LLM providers, each with its own endpoint, credential and per-model parameters (reasoning-effort vocabulary, image input, retry policy), across the OpenAI Chat, OpenAI Responses, Anthropic Messages and Google Gemini wire formats, configured from a settings page.

Declares the OpenCode Go and Command Code route wire protocol and endpoint (so the API address never has to be typed), adds the DeepSeek V4.1 models to the OpenCode Go route and puts them first, completes the Command Code model list from its public catalog, and attaches a per-conversation x-opencode-session header to OpenCode requests (fixes 400 MissingSessionID).

Discovers OpenRouter's free models, measures their real speed and context size, and writes them into the DeepSeek Harness model list fastest-first, with speed and context in each display name, plus a Settings section to configure and run it.

LLM request retry plugin for DeepSeek Harness: when a model request fails with a configured HTTP status code, machine code, or provider field=value match, it sleeps for the per-rule delay and re-issues the request automatically, so subscription quota and rate-limit errors (429 / insufficient_quota) do not interrupt a run.

Use your DSH models in [Libre WebUI](https://github.com/libre-webui/libre-webui) for chat, sandboxed Work and usage tracking, with provider credentials kept in DSH. Requires Libre WebUI 0.37.0 or later.

Brings the Codex (ChatGPT Plus/Pro) subscription already signed in on this machine into DSH. It (1) shows the 5-hour and weekly windows with their reset times and the remaining reset credits in a sidebar panel, with one-click reset that consumes a credit; (2) registers the subscription route in llm-pi-ai (openai-codex) when the quota is read, so the Codex models appear in the model picker; (3) refreshes the OAuth access token before expiry and writes it back atomically, so no key has to be replaced by hand; and (4) adds a codex tool that delegates a task to the local Codex agent. No API key has to be entered.

Qwen multi-modal plugin support.

Multi-account Google Gemini provider: picks the account with the most remaining quota, fails over on 429 with exponential cooldown, probes disabled accounts in the background, and ships a Chinese/English settings page.

Model switching, model capability configuration, fixed compaction models, subagent routing, and input history enhancement.

Bring OpenCode Zen free models to DSH: 8 live-discovered providers with zero config, no API key; includes persistent quota tracker with rate-limit detection and reset countdown.

OAuth sign-in for 9 subscription LLM providers (Claude, Codex, Grok, Antigravity, OpenRouter, Agnes AI, Qwen, Spark, ERNIE) with zero-config login and usage dashboards.

A GUI subagent-model selector beside the main model seat: pick a model and reasoning effort per session, applied to every in-process subagent.

Use local MLX-LM or MLX-VLM models in DeepSeek Harness through a loopback OpenAI-compatible provider, with optional DSH-owned server startup.

Grouped provider and manufacturer model selector for DeepSeek Harness, preserving provider/model routes and reasoning levels.

Settings-UI editor that assigns per-teammate model and reasoning-effort rules for DSH native agent teams, resolved at spawn time by wrapping SubagentRuntime.startContinuable. No official files are modified.

Auto-fills reasoning-efforts, context windows, output limits and image modality for models from unofficial (custom) providers, with data from models.dev. Also provides setting cards to control plugin's behavior.

OpenCode Go provider that verifies a model against the gateway rather than treating a recommendation as a measurement: the models.dev protocol suggestion is probed before it is used, reasoning levels follow a measured contract, and requests run through an ordered protocol fallback chain. Context window, max output and image-input numbers are declared by a runtime-refreshed models.dev layer rather than probed, with operator overrides above both. Several OpenCode Go credentials can be stored and switched from the settings page.

Consult multiple expert advisor models in a retro CRT chat-group card: one ask_advisors call runs an auto-deepen pipeline (driver deep-question, advisor relay, synthesis conclusion) with SSE streaming, 26 provider presets, a configurable daily quota, stop/resume, and optional advisor tool calling.

Calls your own chat.deepseek.com account as a second model from DSH: ask a question, analyze a file's line range, and check login state, plus a runtime skill and a settings-page login panel.

Dual-endpoint Zhipu BigModel GLM provider catalog (Coding Plan and ordinary API) with live model discovery, live-tested thinking-tier mapping, and a settings card for keys, endpoints and the default reasoning tier.

Adds per-route context window and compaction threshold fields to the Models settings page and a vendor-aware thinking-effort picker to the composer, writing llm-pi-ai capacities, reasoningEfforts, and a compaction-basic patch row.

Enable or disable model providers, search models in the selector, and rename provider display names.