Preface¶

DeepSeek Harness (dsh) is an open-source agent runtime developed by DeepSeek, which the official repository summarizes in one sentence: Everything is a plugin. Model adapters, tools, conversations, sandboxes, and web interfaces can all be added or removed at the configuration layer without modifying the core source code. The project is currently in developer preview, and its interfaces will continue to change. Independent plugin directory sites have emerged in the community, aggregating and displaying GitHub repositories tagged with dsh-plugin. It should be noted that such directories have no official affiliation with DeepSeek / Fangzhou (Huan Fang), and cannot be treated as an official app store.

Common pain points when asking models to generate images, videos, or audio in DSH are not about “whether the API calls work”, but that the generated products are scattered everywhere: prompts are in conversations, files are in temporary directories, and reference images cannot be matched with the next generation. Multi-step AIGC often requires splicing, cropping, and frame extraction, and the model needs to remember both the file paths and which image was the input for which generation.

dsh-plugin-aigc-canvas wraps this workflow into a session-level canvas. First, the model calls any AIGC API through a provider-agnostic HTTP tool, then places the saved files on the canvas and connects edges according to reference relationships; built-in ffmpeg post-processing is used for editing tasks. This article is cross-verified based on the community directory details page, GitHub repository source code (src/tools.ts / src/config.ts / src/media-edit.ts), package.json, npm package page, and the official deepseek-ai/deepseek-harness repository. The directory page and README were originally written with the “five types of generation tools + UUID addressing” pattern, while the current main branch has been updated to HTTP bridge + canvas placement/edge connection + ffmpeg; the following content is based on the source code.

What is this¶

dsh-plugin-aigc-canvas is a “model and provider” type plugin maintained by HuanLinOTO, with the npm package name @huanlin/dsh-plugin-aigc-canvas and the repository plugin ID dsh-aigc-canvas. It was added to the community directory on 2026-08-06, is primarily written in TypeScript, and its last push was on 2026-08-15. As of 2026-08-18, the GitHub repository shows 11 stars; the directory page originally showed 6 stars, so refer to the repository page’s data.

The problem it solves can be summarized in one sentence: Let the agent use a unified tool to call your configured AIGC HTTP APIs, save the generated images/videos/audio as canvas elements, and connect edges between references and outputs. It comes with a default stub://aigc-backend provider that does not send real network requests, only synthesizes test media, making it suitable for testing the workflow first.

package.json declares the MIT license, which is also marked on the npm page; there is no LICENSE file in the repository root, and the GitHub license field is empty. Please check the source code yourself before installing.

Core Features¶

The current main branch exposes 8 tools to the model, all bound to the initiating proxy session, so the model does not need to pass a sessionId. The repository introduction mentions “13 tools including reroll”, but there is no aigc_reroll in the source code, nor specialized generation tools like aigc_text_to_image in the directory introduction.

1. Provider Discovery and Instructions

   • aigc_get_provider_info: Lists the ID, name, endpoint, call instructions, whether it is a stub, and whether it is the default provider for all configured providers. The tool description requires calling it before generation. The apiKey will not appear in the response.
   • aigc_provider_set_instructions: Writes the detected API calling syntax back to the provider for use in subsequent sessions. The source code requires keeping it as short as possible, targeting around 200 characters or less, to avoid filling the context when listing providers each time.

2. Provider-agnostic HTTP Bridge: aigc_http_request
   Sends a single HTTP request by provider ID. The endpoint and apiKey are automatically attached by the host, and the model cannot override the authentication header or authentication parameters. Authentication methods can be configured as bearer (default Authorization: Bearer), header, or query.

   The request path is relative to the provider endpoint, for example /v1/images/generations; absolute URLs with the same protocol, host, and port can also be used to fetch download addresses returned by the provider. Binary responses (images/videos/audio) are written to the session canvas directory and return file_path; JSON/text responses are returned inline, and if too long, they are saved to disk. If the response follows the OpenAI image API format { data: [{ b64_json }] }, the tool will extract the image and return the file_path. You can use {"$base64": "<file_path>"} or {"$data_uri": "<file_path>"} in the request body to embed existing files on the canvas, enabling multi-reference generation.

3. Unlimited Canvas: Placement, Edge Connection, Snapshot
   The primary key for elements to the model is the filePath on disk (absolute path within the session canvas directory), not the UUID written in the directory introduction. Internally, UUIDs are used to manage edges, and paths are exposed externally.

   • aigc_canvas_place: Places files already in the canvas directory onto the canvas. You can record prompts and generation parameters (viewable by double-clicking). When references is passed with the filePath of existing elements, edges will be automatically connected from the reference elements to the new element. Do not pass x/y in daily use: with references, the new node will be placed to the right of the reference and vertically centered; otherwise, it will be stacked below existing elements.
   • aigc_canvas_link / aigc_canvas_unlink: Creates or deletes edges by filePath, and is idempotent.
   • aigc_canvas_list_elements: Read-only snapshot that returns all elements and edges, used to retrieve paths after long tool sequences.

   The canvas state is persisted at:

    <cwd>/.dsh-aigc-canvas/<sessionId>/canvas.json

Media files are stored in the same directory, with filenames with UUID extensions. After refreshing the browser or restarting DSH, the canvas will be reloaded from `canvas.json`.

If `dsh-better-sidebar` (peer dependency `^0.4.0`) is installed, a sidebar tab `aigc-canvas:main` will be registered, which subscribes to canvas changes via WebSocket. Without the sidebar, the host-side tools and element list are still available, just without a visual interface.

4. ffmpeg Post-processing: aigc_media_edit
   Input files must already be in the session canvas directory, and outputs are also written back to this directory before being passed to aigc_canvas_place. The operations supported by the source code include:

   • concat: Concatenate 2 or more video clips
   • clip: Crop by start/end time or start time/duration
   • extract_audio: Extract audio track from video (mp3 format)
   • extract_frame: Extract a single frame by timestamp (png format)
   • speed: Change playback speed
   • resize: Resize media
   • reverse: Reverse video and audio
   • add_audio: Replace or add audio track to video
   • images_to_video: Combine multiple images into a slideshow video (default 2 fps)

   ffmpeg is launched with an explicit parameter array, avoiding shell calls; the paths are verified to be within the canvas directory before startup. The machine needs to have ffmpeg available in the PATH (the source code also tried a local default path on Windows, which is not portable).

Installation and Activation¶

The installation command given on the community directory details page is:

dsh plugin add github:HuanLinOTO/dsh-plugin-aigc-canvas

For reproducible installations, pin the commit hash as instructed on the directory page:

dsh plugin add github:HuanLinOTO/dsh-plugin-aigc-canvas#<commit>

Replace <commit> with the actual commit hash from the repository. The repository README and dshfind plugin page recommend installing from npm to the web profile (replace --profile with your active profile name):

dsh plugin --profile web add @huanlin/dsh-plugin-aigc-canvas

As of 2026-08-14, the latest version on npm is 0.1.4; the package.json in the GitHub main branch still lists 0.1.1. The two installation sources may not have identical code, so after choosing one, use the source code from that source as the reference. The engines field requires Node.js >=20. The client manifest marks the platform as web, requiring the dsh web runtime.

The plugin runs with the permissions of the current dsh process, and may execute code during installation. Please check the source code repository and license before installing.

Configuration¶

The provider list can be modified in the DSH GUI settings page; the values in cordis.patch.yml are only the initial startup seed. The default configuration in the source code can be summarized as:

The baseURL / apiKeyEnv in the README correspond to an older single-backend design, which is inconsistent with the current providers array. Do not configure based on the old documentation.

Typical Usage¶

There is no official step-by-step screenshot tutorial. According to the tool descriptions in the source code, a real generation workflow roughly follows this order:

1. Add a provider in the settings page: fill in the endpoint, apiKey, and authentication method. You can start with the default stub provider, which only generates synthetic PNG/MP4/MP3 files to confirm whether the canvas and edge connection functions work.
2. Ask the model to call aigc_get_provider_info first. If the instructions are empty, use aigc_http_request to probe the API (for example, GET the OpenAPI spec, or POST to the generation path according to the provider’s documentation), confirm the request body and response shape, then use aigc_provider_set_instructions to write a short description.
3. Generate content: specify provider_id, path, and json_body in aigc_http_request. After a successful response, take the returned file_path and call aigc_canvas_place, with a description (canvas card label) of no more than 40 characters. If this generation references existing elements, add their filePaths to references.
4. For multi-step tasks, use aigc_canvas_list_elements to retrieve paths, call aigc_media_edit when cropping, frame extraction, or splicing is needed, then place the new files back onto the canvas with aigc_canvas_place.

Below is an example request structure used at the tool layer (specific paths and fields depend on your provider, do not copy verbatim):

{
  "provider_id": "stub",
  "method": "POST",
  "path": "/v1/images/generations",
  "json_body": {
    "prompt": "a sleeping orange cat",
    "size": "1024x1024"
  }
}

For multi-reference generation, embed files on the canvas into the JSON:

{
  "model": "t2v",
  "prompt": "dance",
  "image": { "$base64": "/abs/path/.dsh-aigc-canvas/<sessionId>/<file>.png" }
}

The file_path must be an absolute path within the current session’s canvas directory, and cannot point to arbitrary disk locations.

Applicable Scenarios and Notes¶

This plugin is suitable for developers who are already using dsh web and want the agent to independently complete the workflow of “calling AIGC APIs → saving files to disk → placing files on the canvas and connecting reference-output edges → editing with ffmpeg when necessary”. Providers can be Volcano Engine, Jidemeng, MiniMax, or any HTTP API: the plugin does not bind to a specific provider, only responsible for attaching authentication, saving responses to disk, and managing canvas state.

Before using, please accept these boundaries:
- The plugin runs with the permissions of the current dsh process. aigc_http_request will send the apiKey to your configured endpoint; aigc_media_edit will launch ffmpeg on the local machine. Check the source code and license before installing.
- The default stub provider will not call real models. To generate real images/videos, you must configure your own providers. Do not put secrets in conversations, only store them in the settings.
- Tools cannot read or write elements across sessions. The media routing only provides files within the current session’s canvas directory.
- The routing has a Host header trust fence (similar to DSH /api). When deployed on 0.0.0.0, it relies on the LAN IP list derived from the dsh web launcher.
- The README still lists early limitations such as “elements cannot be deleted/edited, only delete canvas.json and restart the session”; whether the canvas layout and edge drawing have been updated depends on the version of the client you installed. Do not treat the v0.1 limitation table in the README as the current behavior.
- aigc_media_edit depends on the local ffmpeg binary. If it cannot be found, an error will be thrown directly.
- The community directory is not an official app store. Plugins are maintained by individuals, and the version number, tool list, and README may be out of sync with each other. After installation, refer to the actual tool names registered to ctx.tools.

Summary¶

dsh-plugin-aigc-canvas connects “any AIGC HTTP API” and “session-level node canvas” into DeepSeek Harness: the model first queries providers, sends requests, then places files on the canvas and connects edges, with editing handled by ffmpeg. The installation command from the community directory is dsh plugin add github:HuanLinOTO/dsh-plugin-aigc-canvas; you can also install @huanlin/dsh-plugin-aigc-canvas from npm according to the README.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-plugin-aigc-canvas/

GitHub: https://github.com/HuanLinOTO/dsh-plugin-aigc-canvas