OpenKatana · Run plugin operator:
OpenKatana_run_plugin_operator provides a dedicated tool node for requesting a plugin operator action through OpenKatana. It lets you include a plugin-related operation in your ComfyUI workflow instead of calling the underlying tool yourself. The node prepares the request and forwards it to OpenKatana’s tool dispatcher; the actual processing and available capabilities depend on the operator and the plugin implementation. This makes it a bridge to plugin-provided functionality, rather than a built-in image effect with a fixed set of artistic controls. The supplied code does not include the underlying operator’s implementation or argument specification, so it does not establish which effects are available, whether an operation modifies a project, or whether it produces media.
OpenKatana · Run plugin operator Input Parameters:
project_id
A required STRING identifying the OpenKatana project associated with the request. The node passes this value into its argument-preparation step alongside the selected tool and the supplied arguments, allowing the request to be prepared in a project context. Use the identifier provided by your OpenKatana project workflow rather than assuming that a project name or folder path is interchangeable with an identifier. The supplied interface does not specify a default value, allowed identifier format, selectable options, or minimum and maximum length; it also does not show how an unknown project is handled.
arguments
A required STRING containing the arguments to prepare for the plugin operator request. This is where you provide the operator-specific instructions supported by the underlying tool, rather than additional node sockets. The node processes this text through its argument-preparation helpers before dispatching the request, so its contents can affect which action is requested and how that action runs. However, the supplied code does not show the accepted argument schema, required keys, parsing rules, or operator options. Use the argument format documented by your installed OpenKatana tool; if that format is JSON, provide valid JSON with the documented field names and value types. No default value, minimum or maximum length, or predefined choices are supplied in the interface.
after
An optional STRING accepted by the execution method, with a Python default of None when omitted. In the supplied method body, this value is not read, merged into the arguments, or forwarded to the tool dispatcher. Consequently, the visible code does not establish that it changes the operator’s behavior or results. It may be used as a workflow connection when another part of your integration documents that convention, but you should not treat it as a plugin setting or as a demonstrated success-checking mechanism. No text default, allowed options, or minimum and maximum length are shown.
OpenKatana · Run plugin operator Output Parameters:
result_json
The node’s sole output is a STRING carrying the tool result through OpenKatana’s response-formatting helper. Its name indicates that it is intended to represent the result as JSON text, which you can inspect or pass to a compatible downstream text or JSON-processing node. The supplied code does not include the response helper or the plugin operator’s return contract, so it does not establish a fixed set of fields, a success indicator, artifact paths, or error fields. Interpret the content according to the invoked operator’s documented response format, and do not assume that receiving this string necessarily means media was created or a project was modified.
OpenKatana · Run plugin operator Usage Tips:
- Check the installed tool’s signature or documentation before filling in
arguments. The node class constructs its description from a tool description and signature, which may provide information absent from the supplied excerpt. - Use the exact project identifier from your OpenKatana workflow. Keeping the same identifier across related tool calls helps avoid accidentally targeting a different project.
- Start with the smallest documented argument set. Add optional operator settings one at a time so that you can identify which change causes an unexpected result.
- If the tool expects JSON arguments, validate the text before execution: use double-quoted keys and strings, and avoid trailing commas. Do not invent operator names or argument keys based on unrelated OpenKatana tools.
- Inspect
result_jsonafter an initial test before building downstream processing around it. Only rely on response fields confirmed by the actual tool documentation or returned result. - Leave
afterdisconnected unless your workflow needs it for a documented connection pattern. The visible execution method does not use its contents to configure the plugin operation. - Keep plugin files unchanged during execution. The supplied composition code includes an integrity check that can reject execution when tracked plugin inputs change while the plugin environment is active.
OpenKatana · Run plugin operator Common Errors and Solutions:
unexpected inputs: ...
- Explanation: This is an explicit error in the node’s execution method. It occurs when extra named fields are passed to the node that are not part of its declared typed inputs. The message lists the unexpected field names.
- Solution: Use only
project_id,arguments, and the optionalafterinput exposed by this interface. Place operator-specific settings insideargumentsusing the underlying tool’s documented format, rather than adding custom sockets or extra execution fields.
Plugin inputs changed while executing
- Explanation: This exact error appears in the supplied plugin composition code when tracked plugin file hashes differ after execution. It indicates that plugin inputs changed while the plugin environment was active. It applies if this operator uses that composition path; the supplied node wrapper does not prove that every invocation does.
- Solution: Stop editing, replacing, or updating plugin files during a run. Let installation or synchronization tasks finish before retrying, and rerun with a stable set of plugin files.
Argument parsing or validation failure — exact message not provided
- Explanation: The request is passed through argument-preparation helpers before dispatch. Incorrect formatting or arguments that do not match the tool’s contract may therefore prevent execution, although the supplied excerpt does not show the relevant validation rules or error messages.
- Solution: Compare your
argumentstext with the installed tool’s signature and a documented example. If JSON is required, check its syntax first, then verify required fields, spelling, and value types.
Project or operator request rejected — exact message not provided
- Explanation: The underlying tool dispatcher or plugin may reject a request it cannot carry out. The supplied code does not show the corresponding checks or messages, so a missing project, unavailable operator, or unsupported option should be treated as a troubleshooting possibility rather than a confirmed error condition.
- Solution: Read the returned response and available execution logs, verify the project identifier, and confirm that the requested operator and options exist in your installed plugin version. Use the reported details to correct the request rather than assuming a particular response structure.
