OpenKatana · Submit workflow:
OpenKatana_submit_workflow sends an OpenKatana workflow for execution, helping you move from a prepared generation setup to a tracked processing job. It connects to a configured execution service, supports local or cloud execution, and can attach asset files to particular workflow inputs before submission. The underlying submission process saves a workflow copy and a job receipt, records fingerprints of attached assets, and tracks whether submission is in progress, confirmed, or uncertain. It also uses an idempotency key, a submission identifier intended to help the receiving service recognize repeated requests. This makes the node useful for launching repeatable AI-art processing tasks while retaining information for tracking and troubleshooting. Submission is not the same as completion: a successfully submitted job may still need time to run before its creative results are available.
OpenKatana · Submit workflow Input Parameters:
project_id
A required STRING that identifies the OpenKatana project associated with the request. The node passes this value into its argument-preparation step, allowing the tool call to carry the project context alongside the workflow submission details. Use the identifier for the project in which you intend to organize or track the work; this is not the workflow itself or the address of the execution service. The supplied node interface does not define an allowed identifier format, minimum or maximum length, selectable options, or a default value.
arguments
A required STRING containing the submission arguments that the node prepares and forwards to the OpenKatana tool. Supply these as a JSON object encoded as text, using the tool’s argument conventions. The underlying method requires workflow and request_id in addition to the project identifier, and supports settings such as assets, endpoint, native_endpoint, execution, allow_paid, and reviewed_local_nodes; these are entries within the argument payload, not additional node sockets. The backend defaults are endpoint="http://127.0.0.1:8189", native_endpoint="http://127.0.0.1:8000", execution="local", allow_paid=False, and None for both assets and reviewed_local_nodes. The declared execution choices are local and cloud. These settings control where submission is sent, which execution mode is requested, and whether paid execution is permitted. The supplied excerpts do not establish the accepted representation of the workflow string, so confirm whether your installation expects a file reference or another serialized representation rather than assuming that any exported workflow text is accepted. No minimum length, maximum length, or default value for the arguments socket is specified in the supplied interface.
after
An optional STRING accepted by the node’s execution method, with a Python default of None when omitted. In the shown implementation, this value is not read, merged into the submission arguments, or forwarded to the tool invocation. Consequently, the provided code does not establish any effect on workflow settings or submission results. If your surrounding OpenKatana setup uses this socket to connect steps, follow that setup’s documented convention, but do not treat it as a confirmed job-completion dependency based on this excerpt alone. No allowed values, minimum length, maximum length, or interface-level text default are specified.
OpenKatana · Submit workflow Output Parameters:
result_json
A STRING containing the response produced by the OpenKatana tool call, presented as JSON text for inspection or further processing. The node returns a wrapped tool response rather than image data or a finished artwork directly. The underlying submission routine returns a receipt that can include a job_id, a submission state, an idempotency_key, asset records, and reviewed-node information when supplied; the exact outer response structure is not shown. A state of submitted means the service accepted the job and returned its identifier, not that generation has finished. Asset records identify the destination node and input and include a SHA-256 fingerprint, which helps distinguish the exact file used. During submission, the routine also writes receipt states such as submitting and, if the submission call raises an exception, submission_unknown to job.json; because that exception is re-raised, an uncertain submission is not guaranteed to appear as a normal successful output.
OpenKatana · Submit workflow Usage Tips:
- Prepare and validate your workflow before submitting it. The supplied validation code checks the graph against service capabilities and returns readiness information and errors, helping you catch unsupported nodes or incorrect connections before launching a job.
- Keep the visible node inputs separate from the backend settings: enter the project identifier in
project_idand place submission settings insidearguments. Adding sockets namedworkfloworexecutionis not supported by the supplied node interface. - Start with
executionset tolocalandallow_paidset tofalsewhen you want to avoid explicitly authorizing paid execution. Usecloudonly when your OpenKatana service and workflow are configured for it; choosing that option does not itself provision a cloud service. - Check the execution-service address before running. The default
http://127.0.0.1:8189refers to the machine or container running the backend, not necessarily your desktop computer. If the service runs elsewhere, configure an address that the backend can reach. - Verify asset files before attaching them. The underlying submitter resolves each file path, computes its fingerprint, uploads it through the client, and assigns it to the chosen workflow input, so files must be accessible from the environment performing submission.
- Use stable node identifiers and exact input names for asset bindings. The underlying submitter processes bindings in the form
node.input=filename; confirm how the API converts theassetsdictionary into those bindings before constructing a payload. - Keep a record of your
request_idand returned job identifier. The submission process uses an idempotency key, but the supplied excerpts do not show how it is derived from the request, so do not assume that changing or reusing a request identifier is harmless. - If a submission becomes uncertain, check the saved
job.jsonand the execution service before submitting again. The service may have accepted the job even if the client failed to receive its response. - Use
reviewed_local_nodesonly for node types you have actually reviewed. The supplied code passes this list into capability handling and records normalized reviewed-node information in the receipt; it is not evidence that the listed nodes are automatically safe or valid.
OpenKatana · Submit workflow Common Errors and Solutions:
unexpected inputs: ...
- Explanation: This is an explicit error raised by the node when it receives extra named fields that are not part of its supported typed inputs.
- Solution: Use only
project_id,arguments, and the optionalaftersocket. Put backend submission settings inside the argument payload instead of adding unsupported node inputs.
Unknown workflow kind
- Explanation: This exact error appears in the supplied workflow-handling code when a workflow kind is not recognized. It concerns workflow preparation or interpretation and is not necessarily raised for every submission.
- Solution: Check the workflow kind against the kinds supported by your installed OpenKatana version. Correct misspellings or regenerate the workflow using a supported preparation method.
Invalid arguments JSON or missing required submission arguments
- Explanation: The exact error text is not shown, but malformed argument text or missing backend requirements can prevent the request from reaching submission. The backend signature requires
workflowandrequest_idalong with the project identifier. - Solution: Check that
argumentscontains a valid JSON object, with double-quoted keys and strings and lowercase JSON values such astrueandfalse. Include the required submission values and verify the accepted workflow representation in your installation.
Workflow file cannot be read or parsed
- Explanation: The exact error text depends on the failure. The underlying submitter reads a workflow file as UTF-8 text, parses it as JSON, and loads it through the workflow client, so an inaccessible file or malformed JSON can interrupt submission.
- Solution: Confirm that the resolved workflow file exists, is readable by the backend, and contains valid workflow JSON. If your argument payload refers to a file, use a location accessible from the backend rather than a path available only on your desktop.
Workflow validation reports errors
- Explanation: The supplied validation code checks the graph against endpoint capabilities and schema rules. It returns
readyas false when errors exist; the excerpts do not provide the individual validation messages. - Solution: Review each reported error, check the workflow’s node types and connections, and confirm that the target service supports the required nodes. Run validation again after making corrections.
Cannot connect to the execution service
- Explanation: This is a troubleshooting category rather than an exact message from the excerpts. Submission depends on reaching the configured endpoint, so a stopped service, incorrect port, or unreachable host can prevent the workflow from being sent.
- Solution: Confirm that the service is running and that its address is reachable from the OpenKatana backend. Check container networking if applicable, and remember that
127.0.0.1refers to the backend’s own environment.
Asset file or binding cannot be processed
- Explanation: The exact error text is not supplied. Asset processing can fail if a file is missing or unreadable, or if a binding does not contain the expected separators in
node.input=filename. An incorrect node identifier or input name may also prevent assignment. - Solution: Verify the file path and read permissions, then check the destination node identifier and input name against the workflow. Follow your API’s supported
assetsdictionary format rather than assuming that the lower-level binding syntax is itself the complete API payload.
submission_unknown
- Explanation: This is a receipt state, not a standalone exception message. The submitter writes it when
client.submitraises an exception, then re-raises that exception. It indicates that acceptance could not be confirmed; it does not prove that no job was created. - Solution: Inspect
job.json, backend logs, and the service’s job records before retrying. Preserve the original request information so you can investigate the existing submission instead of immediately creating a potentially duplicate job.
The job is submitted, but no finished artwork is returned
- Explanation: A receipt with
stateequal tosubmittedconfirms submission, not execution completion. This node returns the tool response rather than directly returning the job’s generated images. - Solution: Use the returned
job_idwith the job-status and result-retrieval tools available in your OpenKatana installation. Wait for the job to finish before attempting to collect its creative outputs.
