Custom Node Development

Custom Nodes allow you to extend InnoSynth-Forjinn with new logic, internal tools, data sources, or custom integrations. This enables advanced use cases, bespoke automations, and direct feature expansion—turning the platform into a truly open framework for AI workflows.

Overview: When to Create a Custom Node

• Integrate with private/internal APIs
• Add new transformation, analysis, or control logic not present in default library
• Build reusable, parameterized business logic blocks
• Wrap third-party SDKs, libraries, or code modules
• Prototype new workflow patterns and tools for the marketplace

1. Node Scaffold/Structure

Each custom node is typically a TypeScript/JavaScript file that exports an object/class implementing the standard node interface.

Minimum Node Structure:

// MyCustomNode.ts
import { INode, INodeParams, INodeData, ICommonObject } from '.../src/Interface'

class MyCustomNode implements INode {
    label = 'My Custom Node'
    name = 'myCustomNode'
    version = 1.0
    description = 'Does something special'
    type = 'Custom'
    color = '#FFCCCC'
    inputs: INodeParams[] = [
        { label: 'Input Param', name: 'inputParam', type: 'string', required: true }
    ]
    async run(nodeData: INodeData, input: string, options: ICommonObject): Promise<any> {
        // Do your custom logic here
        const myValue = nodeData.inputs?.inputParam
        // Return output in expected format
        return { output: `Hello, ${myValue}` }
    }
}
module.exports = { nodeClass: MyCustomNode }

• Use helper types/interfaces from platform's src/Interface.
• Implement run() as the main function to handle logic.

2. Registering the Node

• Drop the node file (or directory, if complex node) in packages/components/nodes/yourCustom/
• Platform auto-discovers nodes on restart/rebuild; ensure unique name and label.
• Use category and tags for better library organization.

3. Building Advanced Nodes

• Multiple Inputs/Outputs: Add more inputs and output params; use Conditions and Loops programmatically.
• Credential Integration: Add a credential property to link to platform credential manager.
• Async/External Actions: Use HTTP libraries, SDKs, or spawn subprocesses (allow-listed for platform security).
• State Manipulation: Read/update flow state to store values, flags, traces.
• UI Configuration: All inputs and param types map to UI widgets (text, select, date, etc.).

4. Testing & Debugging

• Most errors are visible in run logs and the developer console.
• Trigger the flow/agent containing your custom node via the canvas or API and observe step-by-step in logs.
• Use try/catch and output helpful error messages for downstream users.
• For heavy logic, add "Test Mode" toggles in your config for simulated data.

5. Publishing, Sharing, and Versioning

• Bundle your node(s) for platform plugin sharing (zip or npm modules).
• Add doc comments to your node files—platform can ingest these for auto-generated docs.
• Track node versions and use version control branches for API-breaking changes.
• Toggle experimental features with a config parameter to avoid breaking users.

Common Issues & Troubleshooting

• Node not visible: Check for typos in name/label, file location, or missing module.exports.
• Runtime errors: Use the logs; most exceptions will be shown there.
• UI config misalignment: Make sure inputs match expected types and check the platform doc for new param types.
• Credential or permission error: Node must declare and use credential property correctly.

Developing custom nodes enables limitless automation and integration—share your creation with your team or contribute to the wider platform market!