OpenKatana · Create composition:
OpenKatana_create_composition provides a ComfyUI entry point for calling OpenKatana’s composition-creation tool, allowing you to include composition setup in a node-based creative workflow. OpenKatana’s composition system represents a visual layout as a structured document, with support for containers, text, images, reusable components, styling, and responsive layout rules. This approach is useful when you want to describe a design in a repeatable, editable form rather than work only with a flattened image. The node forwards the request to OpenKatana rather than generating imagery itself. The supplied source shows how composition documents are validated and used by the surrounding system, but does not include the underlying creation tool’s complete implementation; automatic previews, rendering, saving behavior, and a particular starter layout therefore cannot be guaranteed from this context.
OpenKatana · Create composition Input Parameters:
project_id
A required STRING that identifies the OpenKatana project associated with the tool request. The node passes this value into the argument-preparation step, providing project context for the operation. Use the identifier expected by your OpenKatana setup, and keep it consistent with related operations in the same workflow so that your composition work stays associated with the intended project. The supplied interface does not define a default value, a list of available project identifiers, length limits, or whether a missing project can be created automatically.
arguments
A required STRING containing the arguments to be prepared for the composition-creation tool. This is the request-data field exposed by this node; the supplied interface does not expose separate composition settings such as dimensions, document contents, or destination paths. Its contents pass through OpenKatana’s argument-preparation helpers before the tool is invoked, so the accepted structure must match the actual create_composition tool contract. The implementation of those helpers and the creation tool’s argument schema are not included, so required JSON keys, accepted options, empty-value behavior, and defaults cannot be established from the provided source. If your tool documentation specifies JSON, supply valid JSON in the documented structure rather than assuming that a plain-language design prompt or a complete composition document will be accepted. No default value, minimum length, or maximum length is shown.
after
An optional STRING whose Python execution default is None when omitted. The node accepts this value, but its displayed execution method does not read it or pass it to the tool invocation. It therefore has no demonstrated effect on composition content or creation settings in the supplied code. It may serve as a workflow connection point, but no particular dependency-token format or additional behavior is established here. Leave it unconnected unless your surrounding workflow requires it. No string default, minimum length, maximum length, or selectable options are shown.
OpenKatana · Create composition Output Parameters:
result_json
A STRING carrying the result of the OpenKatana tool call after it has been processed by the shared response helper. This is the node’s only output, intended for inspecting or passing along the returned tool response rather than directly supplying a ComfyUI image. The output name indicates a JSON-oriented result, but neither the response helper’s implementation nor the create_composition return schema is included in the provided context. Consequently, specific keys such as a document path, revision, status, or preview location cannot be promised. Inspect the actual response before building downstream field extraction, and do not assume that the inspection and rendering results shown elsewhere in the context are also returned by this creation node.
OpenKatana · Create composition Usage Tips:
-
Confirm the actual create_composition argument schema before filling in
arguments. This wrapper does not expose the tool’s individual settings, and the supplied source does not establish which fields are required inside the request. -
Use the same
project_idacross related composition operations. This helps keep creation, inspection, and subsequent editing requests associated with the intended project. -
If the tool requires JSON, validate it before running the node: use double quotes around property names and text values, and avoid trailing commas. JSON formatting and the tool’s required argument structure are separate requirements, so check both.
-
Inspect
result_jsonafter your first successful call before automating later steps. Build downstream processing around the fields actually returned, rather than assuming that creation also returns rendered frames or a preview. -
When working with composition documents accepted by the tool, give every visual element a unique ID and use only the supported element types:
box,text,image, andcomponent. The supplied composition validator rejects duplicate IDs and unknown types. -
Keep properties appropriate to each element type: containers use
children, text elements usetextorruns, image elements usesrc, and component elements usecomponentandparams. These are composition-document fields, not additional node inputs. -
Keep layouts comfortably below the composition validator’s limits of 1,000 nodes and a nesting depth of 24. Start with a simple layout and add complexity gradually to make validation problems easier to isolate.
-
For later opening or inspection, the supplied code accepts integer canvas dimensions from 16 to 7,680 pixels per side. Start with a modest canvas while checking your layout, then test the intended final size; these are documented limits of the opening code, not separately exposed settings on this node.
-
Leave
afterunused unless needed by your workflow. In the shown execution method, it does not change the tool request or act as a composition setting.
OpenKatana · Create composition Common Errors and Solutions:
Invalid arguments or malformed JSON
- Explanation: The request must pass through argument-preparation helpers before OpenKatana can execute the tool. Incorrect formatting or a structure that does not match the creation tool’s contract can prevent execution. The supplied source does not reveal the exact error messages for these helpers.
- Solution: Check the documented create_composition schema and validate JSON syntax if JSON is required. Do not substitute inspection results, rendering settings, or an arbitrary document for the expected request structure.
unexpected inputs: ...
- Explanation: This exact error prefix is raised by the wrapper when it receives additional named fields that are not declared in its typed input definitions. The authoritative interface lists only
project_id,arguments, andafter. - Solution: Remove unsupported node inputs from custom calls or workflow modifications. Place tool-specific settings inside
argumentsonly when the creation tool’s schema permits them.
Duplicate node ID: ...
- Explanation: The supplied composition validator raises this error when two elements share the same ID. It applies when a composition document reaches this validation path; the creation tool’s exact validation sequence is not shown.
- Solution: Assign a distinct ID to every element, including nested elements. When duplicating a layout section, rename the IDs in the copied section before validating it again.
Unknown node type
- Explanation: The composition validator accepts only
box,text,image, andcomponentas element types. An unsupported name or spelling mistake causes validation to fail. - Solution: Replace the unsupported type with one of the accepted types. For example, use a
boxas a container rather than inventing a type such asgroup.
Fields not applicable to ...
- Explanation: An element contains properties that are not allowed for its type. For example,
childrenis permitted on aboxbut not on animage. - Solution: Check the reported element type and remove or relocate the listed properties. Use
childrenfor boxes,textorrunsfor text,srcfor images, andcomponentorparamsfor components.
Composition exceeds depth/node limit
- Explanation: The composition validator has counted more than 1,000 nodes or encountered nesting deeper than 24 levels. Highly repetitive or deeply nested layouts can reach these limits.
- Solution: Remove unnecessary elements, reduce the number of repeated items, and flatten containers that do not contribute to the layout. Split a large design into simpler compositions if necessary.
dir: auto, ltr or rtl
- Explanation: A composition element contains an unsupported text-direction value. The validator permits only
auto,ltr, andrtl. - Solution: Use
autofor automatic direction,ltrfor left-to-right text, orrtlfor right-to-left text. Check spelling and capitalization.
Invalid responsive width range
- Explanation: Responsive rules are checked with a minimum width between 0 and 7,680 and a maximum width between that minimum and 7,680. Invalid ranges fail validation; the exact numerical error text is not included in the supplied source.
- Solution: Keep both widths within the permitted range and ensure that the maximum is not smaller than the minimum. If omitted, the validator uses 0 for the minimum and 7,680 for the maximum.
Invalid canvas width or height
- Explanation: When a composition is opened by the supplied opening code, width and height must each be integers from 16 to 7,680. The exact error text depends on a validation helper that is not shown.
- Solution: Use whole-number dimensions within that range wherever the tool’s documented schema allows you to configure them. Do not add
widthorheightas separate inputs to this node.
Component expansion is not deterministic
- Explanation: During composition opening, OpenKatana expands components twice and compares the results. This error means the results differed, so the expanded layout could not be considered repeatable.
- Solution: Check custom components for unseeded randomness, current-time values, or other changing data. Use fixed parameters or replace the problematic component with ordinary elements while troubleshooting.
Composition operation timed out
- Explanation: In the supplied browser-based composition runtime, an individual operation is rejected if it does not finish within 30 seconds. This concerns operations that use that runtime; the source does not establish that every creation request starts it.
- Solution: Retry with a simpler composition, check custom components, and confirm that referenced local resources are accessible. If the issue persists, inspect the OpenKatana runtime logs to identify the operation that stalled.
Composition runtime: ...
- Explanation: The browser runtime combines page errors, HTTP failures, blocked requests, and runtime violations under this prefix. An included message such as
HTTP 404: ...identifies a resource that failed to load. - Solution: Read the details after the prefix, check the reported resource paths or component errors, and ensure the composition uses resources permitted by your OpenKatana environment. Correct the underlying issue before retrying.
