Preface

In DeepSeek Harness (DSH), the model commonly outputs Markdown or plain text. To change parameters, check off lists, or drag sliders, users typically have to send another message round, “talking the form contents back”. There’s still a step of friction between this and “the answer itself is a tool that can do work”.

The Intelligent UI plugin introduced below (repository my-dsh/deepseek-intelligent-ui, maintained by my-dsh, classified as client-side in the community) is implemented with reference to thesysdev/open-intelligent-ui: the model writes declarative openui-lang programs via the intelligent_ui tool, and the Harness Web GUI renders them into operable interfaces within the session—checklists, sliders, dropdowns, tables, charts, SVG, etc. Controls are bound to $variables, and interface changes trigger program recomputation, rather than filling out a form and pasting it back to the model.

What Is This

One-sentence positioning: a DSH client plugin that turns “openui-lang programs in tool call arguments” into real-time interactive UI within the chat.

The data flow can be summarized as:

Model ──tool call: intelligent_ui({ title, program })──▶ Session log (tool/call)
                                                        │
Client tool.call.toolview[key=intelligent_ui] ◀─────────┘
  Reads block.call.argsRaw → parse → evaluate → React element tree (with $state)

The Host side only validates and returns diagnostics to the model; rendering is entirely done in the browser, and since the program comes from the session log, the interface can be rebuilt after refresh, replay, or fork.

The npm package name is @my-dsh/dsh-intelligent-ui (version 1.1.0 in the current documentation, MIT license), requiring Harness engine dsh >= 0.2.1-alpha.4.

Core Features

Tools and Language

  • Registers the tool intelligent_ui, with parameters including title and program (openui-lang source).
  • The language uses one statement per line, a single statement cannot be continued on the next line; root is the entry point; components pass arguments positionally.
  • State: $name = default_value; the first parameter of an input component binds to the corresponding $variable.
  • Actions: @Set, @Reset, @OpenUrl, @CopyToClipboard, @ToAssistant, etc., can be combined into Action([...]).
  • Built-in 60+ @functions (such as @Sum, @Payment, @Each, etc.) and 48 UI components (in six groups: layout, text, input, media and data, drawing, interactive). The complete signatures are written into the system prompt by the plugin (src/lang/spec.js), and the model only sees the parts that are actually implemented.

Client Rendering

  • Injects client.js on the Web side via Cordis, mounting the view under the key intelligent_ui in tool.call.toolview.
  • The interface uses host theme tokens (--dsw-alias-*), styles are rendered by components via <style>, and are removed when the line is unloaded.
  • For debugging, window.__DSH_INTELLIGENT_UI__ can be read (version, build time, parseProgram, component/function registration counts, $state, etc.).

Configurable Options

In the profile’s cordis.patch.yml (user layer), you can override configurations for bundle id intelligent-ui (the plugin does not export a Config schema, so no validation is performed):

- id: intelligent-ui
  config:
    prompt: true          # Whether to teach this language in the system prompt, default true
    maxProgramBytes: 60000
    maxDiagnostics: 24

Installation and Activation

Requires DeepSeek Harness with plugin_manager (enabled by default in the Creator preset; external bundles can also be installed from the Plugins page in the Web sidebar).

The package has been published to npm. The package name must include the @my-dsh/ scope—the bare name dsh-intelligent-ui points to another package that has taken the same name, so you would install the wrong package.

Install via the agent’s plugin_manager:

plugin_manager(action="install_bundle", target="@my-dsh/dsh-intelligent-ui")

The repository includes the built client.js, so it works out of the box after installation, no local build needed. In China, if a registry like npmmirror is already configured, pnpm can directly fetch the synced package.

Method 2: Install from the Plugin Market

In the Plugins page of the Web sidebar, enable the experimental “custom plugin market” and add the index source:

https://my-dsh.github.io/deepseek-intelligent-ui/market/index.json

The index only contains this plugin, and installation still resolves to the npm version.

Method 3: Install from GitHub

Also includes client.js, no pre-build needed. Choose one of the following specs:

github:my-dsh/deepseek-intelligent-ui
https://github.com/my-dsh/deepseek-intelligent-ui.git

Installation command:

plugin_manager(action="install_bundle", target="github:my-dsh/deepseek-intelligent-ui")

How It Takes Effect After Installation

install_bundle writes dependencies into the profile and appends @my-dsh/dsh-intelligent-ui to dsh.profile.bundles in package.json. The line that actually activates the plugin comes from the cordis.patch.yml inside the package (bundle layer), for example inserting id intelligent-ui, name @my-dsh/dsh-intelligent-ui. The user layer cordis.patch.yml is applied last and can override the config for the same id.

When upgrading or switching sources, installing an already-installed bundle with the same name returns already-installed, so you need to remove it first and then install:

plugin_manager(action="remove_bundle", target="@my-dsh/dsh-intelligent-ui")
plugin_manager(action="install_bundle", target="@my-dsh/dsh-intelligent-ui")

Typical Usage

Simply describe tasks to the model that require “answers with an interface”, and the model will decide whether to call intelligent_ui. Examples in the README include:

  • “I have one day in San Francisco, help me plan a sightseeing route”
  • “Help me make a 30-year mortgage calculator where I can drag the interest rate and down payment”
  • “Turn my travel checklist into a table that can be checked off and calculates the total price”

A quick overview example of openui-lang (must remain on a single line, consistent with the parser):

$budget = 1200
$days = 3

root = Col([Title("San Francisco One-Day Route", "2xl"), Text(["Total ", Text($days + " days", "md", "muted"), ", budget $", Input($budget, "budget", "number")]), Slider($days, 1, 7, 1, "days", "days"), Chart("bar", @Each(@Range(0, 3), "i", {day: "D" + (i + 1), cost: $budget / $days * (i + 1)}), "day", ["cost"]), Row([Button("Recalculate", @Set($budget, 1500)), Button("Clear", @Reset())])], 4)

For mortgage-type calculations, prefer using @Payment(principal, rate, periods) (rate is the per-period interest rate percentage, periods are in months) to avoid manual formula derivation and silent fallback of enumerated parameters (e.g., Button’s variant only has primary | secondary | ghost | outline | danger).

Applicable Scenarios and Notes

Who It’s For

  • Developers or heavy users who already chat in the DSH Web client and want “on-the-fly adjustable” outputs like itinerary planning, calculators, editable tables/charts.
  • Those willing to let the model learn the openui-lang instructions injected by the plugin and accept the workflow where tool calls land in the session log.

Usage and Troubleshooting

  • Interface blocks render at the message position where the tool call occurs, they don’t float to the top of the window; for long chats or very tall interfaces, users may need to scroll, or call intelligent_ui again in the current context to make the new block appear near the viewport.
  • The interface is within shadow DOM, automation relying on a11y snapshots may not “see” the controls; you can use DOM queries or window.__DSH_INTELLIGENT_UI__ to verify rendering.
  • On parse failure, there is no partial rendering; diagnostics are returned to the model with the tool result, and you can modify the program according to line numbers.

Security and Permissions

The plugin is loaded as part of the DSH profile, the Host-side index.js registers tools and system prompts at process startup; the client client.js executes model-generated programs in the browser. Before installing, you should read the repository source code and the MIT license to confirm it aligns with your current environment’s trust boundary; the plugin runs with the permissions of the current DSH process and Web session, do not install bundles from untrusted sources without review.

The community directory page entry on SkillHub and the GitHub repository are maintained by the community, with no official affiliation with DeepSeek / High-Flyer; the DSH ecosystem follows “everything is a plugin”, and market indexes are for convenient distribution only.

Conclusion

deepseek-intelligent-ui advances model responses from static text to executable openui-lang interfaces: tool validation on the Host, interaction on the client, state binding and recomputation handled by the language and renderer. If you are already using plugin_manager in Harness, you can install @my-dsh/dsh-intelligent-ui via npm, the market, or GitHub as described above, and then use natural language to let the model generate interfaces.