¶ How to Create Fuse Pipeline Components
Fuse Components are modular, policy-aware execution units that power orchestrated workflows across the eTag Fuse platform. They encapsulate integration logic, data transformations, and system interactions, and are automatically registered through the platform’s metadata scanning process.
At installation, Fuse scans assemblies for annotated classes, methods, and properties using platform-specific attributes. These annotations allow the platform to auto-discover, register, and enforce behavior across pipeline executions — including validation, UI rendering, data type handling, and runtime control.
Every external property, method, and method argument must be properly annotated. Missing metadata will result in warnings, and the component may be marked as defective by the runtime.
This guide walks through everything you need to create and publish valid Fuse Components — including architecture, attribute usage, supported types, lifecycle considerations, and best practices.
¶ 1. Introduction
Fuse Components serve as governed, interoperable building blocks within the eTag Fuse platform. They enable cross-domain workflows by abstracting integration logic, data transformation, and connectivity into reusable execution units.
Components can be used to:
Transform structured or unstructured data
Connect to external APIs or systems
Automate execution steps in orchestrated pipelines
Fuse uses metadata annotations to:
Discover components automatically — scanning assemblies at installation
Generate UI definitions and runtime bindings — including type hints and parameter metadata
Enforce rules and behavior consistently — validating structure, access, and integration patterns
If any required annotation is missing, Fuse logs a warning and prevents the component from being registered, ensuring stability and traceability across environments.
¶ 2. Fuse Component Architecture
¶ 2.1 The Role of Metadata
-
Self-Describing Components:
Fuse relies on metadata annotations to understand your component’s functionality. Annotations include names, descriptions, UI details (icons, colors), integration patterns, and supported data types. -
Automatic Discovery:
During installation, Fuse scans assemblies for classes marked with[Component]and for methods, properties, and method arguments marked with attributes such as[Method],[MethodArgument], and[Property]. This metadata is used to register components and make them available for pipeline flows. -
Integration in Pipelines:
Once registered, components become available as drag-and-drop execution steps within the Fuse orchestration layer. Their metadata drives:- UI generation (labels, icons, parameter hints)
- Runtime enforcement (input/output validation, scoped access)
- Message routing and transformation within pipeline flows
¶ 2.2 Inheritance Models
Fuse supports two primary inheritance models based on integration requirements:
¶ Component Base Class
Use this for components such as adapters and transformers. These components work within the Fuse pipeline and perform internal data manipulation without relying on HTTP communication.
Example:
/// <summary>Use this adapter to perform string operations against the message payload.</summary>
[Component(
Name = "Strings",
Category = "Data",
Description = "Use this adapter to perform transformation operations against a string message payload.",
UIIconSID = "fal fa-font",
IconColor = "#4169E1"
)]
public class Strings : Component
{
/// <summary>Gets or sets the type of component.</summary>
public override ComponentTypeType Type { get { return ComponentTypeType.Adapter; } }
/// <summary>Gets the component's intended integration pattern.</summary>
public override ComponentIntegrationPatternType IntegrationPattern { get { return ComponentIntegrationPatternType.Pipeline; } }
// Component implementation...
}
¶ BaseRestConnector
For REST-based integrations, inherit from BaseRestConnector (which itself extends Component). This class includes built-in support for constructing and sending HTTP requests, making it ideal for API connectors.
Example:
[Component(
Name = "Groq AI",
Category = "AI",
UIIconSID = "Groq",
IconBase64 = "data:image/png;base64,...",
Description = "Groq Connector. Provides access to Groq's LPU™ Inference Engine.",
Company = "Groq",
CompanyUrl = "https://groq.com/",
Developer = "eTag Technologies Inc.",
DeveloperUrl = "https://www.etagtechnologies.com",
ApiUrl = "https://api.groq.com/openai/"
)]
public partial class GroqAIConnector : BaseRestConnector
{
/// <summary>Gets or sets the type of component.</summary>
public override ComponentTypeType Type { get { return ComponentTypeType.Connector; } }
/// <summary>Gets the component's intended integration pattern.</summary>
public override ComponentIntegrationPatternType IntegrationPattern { get { return ComponentIntegrationPatternType.API | ComponentIntegrationPatternType.AI; } }
// Component implementation...
}
¶ 2.3 Specifying the Component Type
Override the Type property in your component class to specify its type. You can combine flags using bitwise OR to indicate multiple roles (e.g., an Adapter that is also Experimental, or a component that functions as both a Connector and an Adapter).
The Type property is required and must be implemented.
The available component type options include:
¶ 2.3.1 Process:
Indicates that the component type is a process. This flag is typically used when the component represents a distinct processing step within the pipeline that executes business logic or other workflow operations.
Process Component Example:
public override ComponentTypeType Type { get { return ComponentTypeType.Process; } }
¶ 2.3.2 Connector:
Indicates that the component type is a connector.
Remark: Used to signal that the component is able to bring messages in and out of the Fuse process pipeline. This is ideal for components that interact with external systems or APIs.
Connector Component Example:
public override ComponentTypeType Type { get { return ComponentTypeType.Connector; } }
¶ 2.3.3 Adapter:
Indicates that the component type is an adapter.
Remark: This option shows that the component is designed to perform transformation operations against messages. Adapters typically alter data formats, manipulate payloads, or perform similar transformation tasks within the pipeline.
Adapter Component Example:
public override ComponentTypeType Type { get { return ComponentTypeType.Adapter; } }
¶ 2.3.4 Utility:
Indicates that the component type is a utility.
Remark: Utility components are designed to provide supporting functions that may not directly process or transform messages, but offer common functionality or helper operations across the Fuse platform.
Utility Component Example:
public override ComponentTypeType Type { get { return ComponentTypeType.Utility; } }
¶ 2.3.5 Experimental:
Indicates that the component type is currently experimental.
Remark: Components marked as experimental might have their functionality or features change in future releases. Use this flag when you’re testing new concepts or functionality that is not yet finalized.
Experimental Component Example:
public override ComponentTypeType Type
{
get
{
return ComponentTypeType.Adapter | ComponentTypeOptionsType.Experimental;
}
}
¶ 2.4 Specifying the Component IntegrationPattern
In addition to defining the component type, you must also implement the IntegrationPattern property. This property informs Fuse of the intended integration scenario(s) for your component. You can combine multiple flags using bitwise OR to indicate that a component supports more than one integration pattern.
The IntegrationPattern property is required and must be implemented.
The available integration pattern options are:
-
Pipeline:
Indicates the component is intended for pipeline integration.
Remarks: Use for components that can be used across different integration patterns. -
Application:
Indicates the component is intended for Application integrations.
Remarks: Use for application-specific components. -
API:
Indicates the component is intended for API integrations. -
Storage:
Indicates the component is intended for storage integrations. -
ETL:
Indicates the component is intended for ETL integrations. -
Device:
Indicates the component is intended for device integrations. -
Data:
Indicates the component is intended for data integrations. -
CICD:
Indicates the component is intended for CI/CD integrations.
Remarks: Use for components that support continuous deployment (CD), configuration as code (CAC), and continuous testing (CT) integration patterns. -
KnowledgeBase:
Indicates the component is intended for Knowledge-base integrations. -
Simulation:
Indicates the component is intended for simulation integrations. -
Discovery:
Indicates the component is intended for discovery service integrations. -
Payment:
Indicates the component is intended for payment processing service integrations. -
Containerization:
Indicates the component is intended for containerization integrations. -
Notification:
Indicates the component is intended for notification integrations. -
Logging:
Indicates the component is intended for logging integrations. -
Security:
Indicates the component is intended for security integrations. -
Reporting:
Indicates the component is intended for reporting service integrations. -
ImageProcessing:
Indicates the component is intended for image processing services. -
Fuse:
Indicates the component is intended for fuse integrations. -
AI:
Indicates the component is intended for artificial intelligence service integrations. -
Documents:
Indicates the component is intended for documents integrations. -
Contents:
Indicates the component is intended for contents integrations. -
Markets:
Indicates the component is intended for markets integrations. -
CRM:
Indicates the component is intended for CRM (customer relationship management) service integrations. -
Web:
Indicates the component is intended for Web service integrations. -
Environment:
Indicates the component is intended for environment integrations. -
Synchronization:
Indicates the component is intended for synchronization service integrations. -
Provisioning:
Indicates the component is intended for provisioning service integrations. -
Messaging:
Indicates the component is intended for messaging service integrations. -
Communication:
Indicates the component is intended for communication network integrations.
Example Usage:
/// <summary>Gets the component's intended integration pattern.</summary>
public override ComponentIntegrationPatternType IntegrationPattern
{
get
{
return ComponentIntegrationPatternType.Data |
ComponentIntegrationPatternType.Contents |
ComponentIntegrationPatternType.KnowledgeBase;
}
}
¶ 2.4 Organizing Large Components
For complex components with many methods or extensive functionality, consider splitting your component’s code into multiple files using partial classes. This modular organization improves maintainability and clarity.
Example: Groq AI Connector Organization
- GroqAIConnector.cs: Contains core properties, authentication, and fundamental REST logic.
- GroqAIConnectorChat.cs: Contains chat-specific methods such as creating chat completions.
- GroqAIConnectorModels.cs: Contains methods to retrieve model information.
¶ 3. The Attribute Framework
Annotations in Fuse are implemented via custom attributes that serve as metadata. These attributes guide the Fuse runtime in generating client-side code, rendering the Fuse UI, and enforcing integration rules.
¶ 3.1 Component Attribute
The Component Attribute is applied to classes to mark them as Fuse Components. It inherits from MemberAttribute, so it includes both its own properties and those defined in MemberAttribute. These properties provide Fuse with all the necessary metadata to discover, register, and present your component.
Below is a detailed table of all properties available on a Component Attribute:
| Property | Type | Description | Default |
|---|---|---|---|
| Name | string |
Gets or sets the name of the Fuse component. | — |
| Options | ComponentTypeOptionsType |
Gets or sets the component options. Flags indicate capabilities such as pipeline support, step execution, attributes, licensing requirements, etc. |
— |
| Version | string (internal) |
Sets the version of the component. | — |
| InputTypes | Type[] |
Gets a list of supported inbound message types. | — |
| OutputTypes | Type[] |
Gets a list of supported outbound message types. | — |
| Company | string |
Gets the company name of the vendor. | — |
| CompanyUrl | string |
Gets the URL for the vendor’s company. | — |
| Developer | string |
Gets the component developer's name. | — |
| DeveloperUrl | string |
Gets the URL for the component developer. | — |
| SupportUrl | string |
Gets the support URL for the component (applies to Fuse components). | — |
| ApiUrl | string |
Gets the vendor API URL. | — |
| DeprecatorType | Type |
Gets the type used for deprecation logic. | — |
| UIIconSID | string |
Gets or sets the UI icon system identifier used to display the component in the Fuse UI. | — |
| IconColor | string |
Gets or sets the icon color. | "#000" |
| IconBase64 | string |
Gets or sets the base 64 encoded icon. (Typically a 512×512px, 32-bit PNG in sRGB.) | — |
| Category | string |
Gets or sets the category under which the component is grouped. | — |
| Description | string |
Gets or sets the description of the component. | — |
| Instructions | string |
Gets or sets any instructions for using the component. | — |
| ReturnsNotes | string |
Gets or sets notes regarding what the component returns. | — |
| DeprecationNotes | string |
Gets or sets notes regarding deprecation of the component. | — |
| Remarks | string |
Gets or sets additional remarks or comments about the component. | — |
| HelpUrl | string |
Gets or sets the URL for help related to the component. | — |
| HelpText | string |
Gets or sets the help text for the component. | — |
| User1, User2, User3 | string (each) |
Gets or sets user-defined fields for custom information. | — |
| ApiOptions | MemberApiOptionsType |
Gets or sets the API options that determine how the member is transmitted in API calls. | — |
| AIOptions | MemberAIOptionType |
Gets or sets the AI options for integration with AI functionalities. | AssistantsAPI | ChatCompletionAPI |
| Alias | string |
Gets or sets alternative names (aliases) for the member. Multiple aliases can be separated by a semicolon (;). |
— |
Example Usage:
[DataProcessor(ConnectionString = "ETAG-FUSE-SYSTEM-DB")]
[Component(
Name = "Groq AI",
Category = "AI",
UIIconSID = "Groq",
IconBase64 = "",
Description = "Groq Connector. Provides access to Groq's LPU™ Inference Engine.",
Company = "Groq",
CompanyUrl = "https://groq.com/",
Developer = "eTag Technologies Inc.",
DeveloperUrl = "https://www.etagtechnologies.com",
ApiUrl = "https://api.groq.com/openai/"
)]
public partial class GroqAIConnector : BaseRestConnector
{
// Component implementation...
}
¶ 3.2 Property Attribute
The Property Attribute is applied to properties to mark them as Fuse properties. It inherits from MemberAttribute and is used to configure and persist component settings. The properties are grouped below for clarity.
| Property | Type | Description | Default |
|---|---|---|---|
| BehaviorOptions | PropertyBehaviorOptionType |
Behavior options for the property. | — |
| Data | string |
Additional data for the property. | — |
| DataKeyExcludes | string[] |
A list of keys to exclude from the property data. | — |
| DataOptions | PropertyDataOptions |
Options related to the property's data. | — |
| DefaultIcon | string |
The default icon. | — |
| DefaultName | string |
The default name. | — |
| DescriptionOptions | PropertyInfoDisplayOptions |
Options for displaying the description (e.g., tooltip). | Tooltip |
| ElementOptions | PropertyElementOptionType |
Element options for the property. | — |
| EnableExpression | string |
Expression that enables/disables the property. | — |
| EntityOptions | EntityOptionsType |
The entity options. | — |
| EntitySID | string |
The entity system identifier. | — |
| FailMessage | string |
Message displayed when validation fails. | — |
| FileAccept | string |
Accepted file types. | — |
| FileMaxFiles | int |
Maximum number of files allowed. | — |
| FileMaxFilesError | string |
Error message when maximum files are exceeded. | — |
| FileMaxSize | int |
Maximum file size allowed. | — |
| FileMaxSizeError | string |
Error message when the file size is exceeded. | — |
| FileNameError | string |
Error message when the file name is invalid. | — |
| FileNameExpr | string |
Expression used to determine the file name. | — |
| FileMode | string |
The file mode. | — |
| FileOptions | PropertyFileOptionType |
File-specific options. | — |
| FileText | string |
File text. | — |
| FileThumbnailHeight | string |
Thumbnail height for file previews. | — |
| FileThumbnailWidth | string |
Thumbnail width for file previews. | — |
| Group | string |
The group to which the property belongs. | — |
| IconOptions | IconOptionType |
Options that control how the icon is displayed. | — |
| LayoutOptions | PropertyLayoutOptionType |
Layout options for the property. | — |
| Max | string |
The maximum value allowed. | — |
| MaxLength | int |
Maximum length for the property's input. | — |
| Min | string |
The minimum value allowed. | — |
| Name | string |
The property name. | — |
| NameDataField | string |
The name data field used for manager integration. | — |
| NullDisplayText | string |
Display text for a null value. | — |
| Options | PropertyOptionType |
Options such as Persist, Deprecated, etc. | — |
| Pattern | string |
The validation pattern for the property. | — |
| Placeholder | string |
The placeholder text for the property. | — |
| PrimitiveType | string |
The primitive data type. | — |
| PropertyProviderSID | string |
The property provider system identifier. | — |
| RemarksOptions | PropertyInfoDisplayOptions |
Options for displaying remarks. | Tooltip |
| RequiredIndicator | string |
Indicator showing the property is required. | — |
| RequiredIndicatorColor | string |
The color of the required indicator. | — |
| Scope | PropertyScopeType |
The scope (e.g., Instance, Global). | Instance |
| Section | string |
The section where the property appears. | — |
| SortOrder | int |
Sort order in the UI. | 999 |
| Step | string |
The legal interval (step) for numeric inputs. | — |
| Text | string |
The display text for the property. | — |
| UIAttributes | string |
UI input attributes for rendering the property. | — |
| UIPageSID | string |
UI page system identifier used to modify the property. | — |
| UISelectorNameDataField | string |
The selector name data field for manager integration. | — |
| UISelectorValueDataField | string |
The selector value data field for manager integration. | — |
| UserMember | string |
The user member. | — |
| UserProperty | string |
The user property name. | — |
| ValueConverter | Type |
Specifies the value converter type used to convert the parameter’s value. |
— |
| ValueExpression | string |
Expression that determines the property’s value. | — |
| Version | string |
The version of the property. | — |
| FalseDisplayText | string |
Display text for a boolean false value. | — |
| TrueDisplayText | string |
Display text for a boolean true value. | — |
Example Usage:
[Property(
Text = "Endpoint URL",
Category = "Request",
SortOrder = 500,
DefaultValue = "https://api.groq.com/openai/v1",
Description = "The Groq API base endpoint URL."
)]
public override string EndpointUrl { get; set; }
¶ 3.3 Method Attribute
The Method Attribute marks a method as a Fuse method and specifies its exposure and execution details. It inherits from Member Attribute, thus including common metadata properties alongside its own specific properties.
| Property | Type | Description | Default |
|---|---|---|---|
| BulkOptions | MethodBulkOptionsType |
Options for handling bulk operations (e.g., mergeable results, multithreading). | — |
| ClientExpression | string |
An expression executed on the client side when the method is invoked. | — |
| InputTypes | Type[] |
The payload types accepted by the method. | — |
| IntegrationPattern | MethodIntegrationPatternType |
Defines the method’s integration role (e.g., Transformation, Filtering, Routing). | — |
| MethodArguments | Dictionary<string, MethodArgumentAttribute> |
A collection of metadata for each method parameter. Every external parameter must be annotated; otherwise, Fuse logs a warning. |
— |
| MethodType | MethodTypeType |
Specifies the type of method (e.g., Command, Step, Task, or lifecycle events like OnStart, OnStop). | — |
| Options | MethodOptionType |
Flags that control method behavior (e.g., omittable steps, asynchronous execution, bulk processing). | — |
| OutputTypes | Type[] |
The payload types that may be output by the method. | — |
| PaginationOptions | MethodPaginationOptionsType |
Options for handling pagination (e.g., offsetable, cursorable, pageable). | — |
| RequiredScopes | string |
Specifies any required authorization scopes for executing the method. | — |
| ResultDestinationOptions | MethodResultDestinationOptionType |
Determines where the method’s output should be directed (e.g., payload, variable). | — |
| RetryOverride | bool |
Indicates whether the method should override the default retry behavior. | false |
| UIAOptions | MethodUIAOptionType |
Options for UI Automation that control how the method’s output is handled in automated environments. |
— |
| UIAType | string |
Specifies the type for UI Automation. | — |
| UIPageSID | string |
The system identifier for the UI page used to specify method arguments. | — |
| Text | string |
The display text or label for the method. | — |
| Version | string |
The version of the method. |
Example Usage:
/// <summary>Creates a model response for the given chat conversation.</summary>
/// <param name="message">The message. Internal use.</param>
/// <param name="messages">A list of messages comprising the conversation so far.</param>
/// <param name="model">The ID of the model to use. The default is 'llama-3.1-8b-instant'.</param>
/// <param name="frequencyPenalty">Number between -2.0 and 2.0.</param>
/// <param name="maxTokens">The maximum number of tokens to generate in the chat completion.</param>
/// <param name="n">How many chat completion choices to generate for each input message.</param>
/// <param name="presencePenalty">Number between -2.0 and 2.0.</param>
/// <param name="responseFormat">An object specifying the format that the model must output.</param>
/// <param name="seed">This feature is in Beta.</param>
/// <param name="stop">Up to 4 sequences where the API will stop generating further tokens.</param>
/// <param name="stream">If set, partial message deltas will be sent, like in ChatGPT.</param>
/// <param name="temperature">What sampling temperature to use, between 0 and 2.</param>
/// <param name="topP">An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens.</param>
/// <param name="tools">A list of tools the model may call. Currently, only functions are supported as a tool.</param>
/// <param name="toolChoice">Controls which (if any) function is called by the model.</param>
/// <param name="parallelToolCalls">Whether to enable parallel function calling during tool use.</param>
/// <param name="user">A unique identifier representing your end-user, which can help GroqAI to monitor and detect abuse.</param>
[Method(
Text = "Create Chat Completion",
Category = "Chat",
Description = "Creates a model response for the given chat conversation.",
MethodType = MethodTypeType.Command | MethodTypeType.Task | MethodTypeType.Step,
Options = MethodOptionType.OmittableSteps | MethodOptionType.OmitSteps | MethodOptionType.OmittablePipelineFlow | MethodOptionType.OmitPipelineFlow | MethodOptionType.Bulkable | MethodOptionType.OptionablePayload,
BulkOptions = MethodBulkOptionsType.Multithreadable | MethodBulkOptionsType.MergeableResults
)]
[MethodArgument(
Name = "messages",
Text = "Messages",
Description = "A list of messages comprising the conversation so far.",
ValueConverter = typeof(CommonConverter<List<ChatCompletionMessage>>),
Options = PropertyOptionType.MultiLine | PropertyOptionType.Expression
)]
[MethodArgument(
Name = "model",
Text = "Model",
DefaultValue = "llama-3.1-8b-instant",
Description = "The ID of the model to use. The default is 'llama-3.1-8b-instant'.",
Options = PropertyOptionType.Required | PropertyOptionType.Expression
)]
[MethodArgument(
Name = "frequencyPenalty",
Text = "Frequency Penalty",
DefaultValue = "0",
Step = "0.1",
Min = "-2.0",
Max = "2.0",
Description = "Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far...",
ElementOptions = PropertyElementOptionType.Number
)]
[MethodArgument(
Name = "maxTokens",
Text = "Max Tokens",
Min = "1",
Description = "The maximum number of tokens to generate in the chat completion.",
Remarks = "The total length of input tokens and generated tokens is limited by the model's context length."
)]
[MethodArgument(
Name = "logprobs",
Text = "Log Probabilities",
Description = "Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message."
)]
[MethodArgument(
Name = "toplogprobs",
Text = "Top Log Probabilities",
Description = "An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used."
)]
[MethodArgument(
Name = "n",
Text = "N",
DefaultValue = "1",
Description = "How many chat completion choices to generate for each input message. The default is 1.",
Remarks = "Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs."
)]
[MethodArgument(
Name = "presencePenalty",
Text = "Presence Penalty",
DefaultValue = "0",
Step = "0.1",
Min = "-2.0",
Max = "2.0",
Description = "Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.",
ElementOptions = PropertyElementOptionType.Number
)]
[MethodArgument(
Name = "responseFormat",
Text = "Response Format",
Description = "An object specifying the format that the model must output.",
Remarks = @"Setting to { ""type"": ""json_object"" } enables JSON mode, which guarantees the message the model generates is valid JSON.",
ValueConverter = typeof(CommonConverter<ResponseFormat>),
Options = PropertyOptionType.MultiLine
)]
[MethodArgument(
Name = "seed",
Text = "Seed",
Min = "1",
Description = "This feature is in Beta. If specified, our system will make a best effort to sample deterministically.",
Remarks = "Determinism is not guaranteed, and you should refer to the system_fingerprint response parameter to monitor changes in the backend."
)]
[MethodArgument(
Name = "stop",
Text = "Stop",
ValueConverter = typeof(CommonConverter<List<string>>),
Description = "Up to 4 sequences where the API will stop generating further tokens."
)]
[MethodArgument(
Name = "stream",
Text = "Stream",
Description = "If set, partial message deltas will be sent, like in ChatGPT."
)]
[MethodArgument(
Name = "temperature",
Text = "Temperature",
DefaultValue = "1",
Step = "0.1",
Description = "What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random.",
Remarks = "Its generally recommend altering this property or 'Top P' but not both.",
ElementOptions = PropertyElementOptionType.Number
)]
[MethodArgument(
Name = "topP",
Text = "Top P",
DefaultValue = "1",
Step = "0.1",
Description = "An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.",
Remarks = "Its generally recommend altering this property or 'Temperature' but not both.",
ElementOptions = PropertyElementOptionType.Number
)]
[MethodArgument(
Name = "tools",
Text = "Tools",
Description = "A list of tools the model may call. Currently, only functions are supported as a tool.",
ValueConverter = typeof(CommonConverter<List<Tool>>),
Options = PropertyOptionType.MultiLine
)]
[MethodArgument(
Name = "toolChoice",
Text = "Tool Choice",
Description = @"Controls which (if any) function is called by the model.",
Options = PropertyOptionType.MultiLine
)]
[MethodArgument(
Name = "parallelToolCalls",
Text = "Parallel Tool Calls",
Description = "Whether to enable parallel function calling during tool use."
)]
[MethodArgument(
Name = "user",
Text = "User",
Description = "A unique identifier representing your end-user, which can help GroqAI to monitor and detect abuse."
)]
public void CreateChatCompletion(
Message message,
List<ChatCompletionMessage> messages,
string model,
float frequencyPenalty,
int maxTokens,
int n,
float presencePenalty,
ResponseFormat responseFormat,
int seed,
List<string> stop,
bool stream,
float temperature,
float topP,
object tools,
string toolChoice,
bool parallelToolCalls,
string user
)
{
if (maxTokens == 0)
maxTokens = 100;
if (temperature == 0)
temperature = 1;
this.Send(message, new ChatCompletionRequest(REST.RequestTypeType.Create)
{
Messages = messages,
Model = model ?? "llama-3.1-8b-instant",
FrequencyPenalty = frequencyPenalty,
MaxTokens = maxTokens,
N = n,
PresencePenalty = presencePenalty,
ResponseFormat = responseFormat,
Seed = seed,
Stop = stop,
Stream = stream,
Temperature = temperature,
TopP = topP,
Tools = tools,
ToolChoice = toolChoice,
ParallelToolCalls = parallelToolCalls,
User = user
});
}
¶ 3.4 MethodArgument Attribute
The MethodArgument Attribute provides metadata for individual method parameters. This metadata is used by Fuse to validate, convert, and display parameters appropriately. It includes properties specific to the parameter, such as a reference to its reflection metadata and an optional value converter.
Note: The MethodArgument Attribute derives from the Property Attribute, so it contains all the same members.
| Property | Type | Description | Default |
|---|---|---|---|
| BehaviorOptions | PropertyBehaviorOptionType |
Behavior options for the property. | — |
| Data | string |
Additional data for the property. | — |
| DataKeyExcludes | string[] |
A list of keys to exclude from the property data. | — |
| DataOptions | PropertyDataOptions |
Options related to the property's data. | — |
| DefaultIcon | string |
The default icon. | — |
| DefaultName | string |
The default name. | — |
| DescriptionOptions | PropertyInfoDisplayOptions |
Options for displaying the description (e.g., tooltip). | Tooltip |
| ElementOptions | PropertyElementOptionType |
Element options for the property. | — |
| EnableExpression | string |
Expression that enables/disables the property. | — |
| EntityOptions | EntityOptionsType |
The entity options. | — |
| EntitySID | string |
The entity system identifier. | — |
| FailMessage | string |
Message displayed when validation fails. | — |
| FileAccept | string |
Accepted file types. | — |
| FileMaxFiles | int |
Maximum number of files allowed. | — |
| FileMaxFilesError | string |
Error message when maximum files are exceeded. | — |
| FileMaxSize | int |
Maximum file size allowed. | — |
| FileMaxSizeError | string |
Error message when the file size is exceeded. | — |
| FileNameError | string |
Error message when the file name is invalid. | — |
| FileNameExpr | string |
Expression used to determine the file name. | — |
| FileMode | string |
The file mode. | — |
| FileOptions | PropertyFileOptionType |
File-specific options. | — |
| FileText | string |
File text. | — |
| FileThumbnailHeight | string |
Thumbnail height for file previews. | — |
| FileThumbnailWidth | string |
Thumbnail width for file previews. | — |
| Group | string |
The group to which the property belongs. | — |
| IconOptions | IconOptionType |
Options that control how the icon is displayed. | — |
| LayoutOptions | PropertyLayoutOptionType |
Layout options for the property. | — |
| Max | string |
The maximum value allowed. | — |
| MaxLength | int |
Maximum length for the property's input. | — |
| Min | string |
The minimum value allowed. | — |
| Name | string |
The property name. | — |
| NameDataField | string |
The name data field used for manager integration. | — |
| NullDisplayText | string |
Display text for a null value. | — |
| Options | PropertyOptionType |
Options such as Persist, Deprecated, etc. | — |
| Pattern | string |
The validation pattern for the property. | — |
| Placeholder | string |
The placeholder text for the property. | — |
| PrimitiveType | string |
The primitive data type. | — |
| PropertyProviderSID | string |
The property provider system identifier. | — |
| RemarksOptions | PropertyInfoDisplayOptions |
Options for displaying remarks. | Tooltip |
| RequiredIndicator | string |
Indicator showing the property is required. | — |
| RequiredIndicatorColor | string |
The color of the required indicator. | — |
| Scope | PropertyScopeType |
The scope (e.g., Instance, Global). | Instance |
| Section | string |
The section where the property appears. | — |
| SortOrder | int |
Sort order in the UI. | 999 |
| Step | string |
The legal interval (step) for numeric inputs. | — |
| Text | string |
The display text for the property. | — |
| UIAttributes | string |
UI input attributes for rendering the property. | — |
| UIPageSID | string |
UI page system identifier used to modify the property. | — |
| UISelectorNameDataField | string |
The selector name data field for manager integration. | — |
| UISelectorValueDataField | string |
The selector value data field for manager integration. | — |
| UserMember | string |
The user member. | — |
| UserProperty | string |
The user property name. | — |
| ValueConverter | Type |
Specifies the value converter type used to convert the parameter’s value. | — |
| ValueExpression | string |
Expression that determines the property’s value. | — |
| Version | string |
The version of the property. | — |
| FalseDisplayText | string |
Display text for a boolean false value. | — |
| TrueDisplayText | string |
Display text for a boolean true value. | — |
Example Usage:
[MethodArgument(
Name = "model",
Text = "Model",
DefaultValue = "llama-3.1-8b-instant",
Description = "The ID of the model to use. The default is 'llama-3.1-8b-instant'.",
Options = PropertyOptionType.Required | PropertyOptionType.Expression
)]
¶ 4. Message Argument and Payloads
Important Principle:
Component methods should always include the message argument as the first parameter. This is not optional—Fuse uses the message as the core unit of data exchange within a pipeline process.
¶ What is a Message?
In the Fuse Component Framework, a message carries the payload (i.e., the data) from one component to another as it flows through the pipeline. Additionally, messages include metadata that supports:
- Routing: Directing messages through the appropriate processing steps.
- Transformations: Modifying the payload as it moves along.
- Conditional Processing: Making decisions based on dynamic metadata.
Messages are dynamic and adaptable. They evolve as they progress through the pipeline, allowing for complex workflows such as:
- Data enrichment
- Conditional branching
- Payload transformations
¶ Examples in Context
Bytes Adapter Example:
In the Bytes adapter, methods process the payload contained within the message. Every method begins with a Message message parameter.
public override void OnDefaultStep(Message message)
{
if (message.Payload is byte[] bdata)
{
// Convert the byte array to a Unicode string.
message.Payload = UnicodeEncoding.Unicode.GetString(bdata, 0, bdata.Length);
}
// Additional handling for other payload types.
}
Compression Adapter Example:
The Compression adapter also starts its methods with the message argument, ensuring the payload is processed correctly whether it is a byte array or a MemoryStream.
[Method(
MethodType = MethodTypeType.Step,
InputTypes = new Type[] { typeof(byte[]), typeof(MemoryStream) },
Description = "Compress payload using the Deflate algorithm."
)]
public void Compress(Message message)
{
if (message.Payload is byte[] bytes)
{
using (MemoryStream output = new MemoryStream())
{
using (DeflateStream compressor = new DeflateStream(output, CompressionMode.Compress))
compressor.Write(bytes, 0, bytes.Length);
message.Payload = output.ToArray();
}
}
// Additional handling for other payload types.
}
Groq AI Connector Example:
Even in REST-based connectors, the first parameter is always the message to ensure that both the payload and its associated metadata (like authorization details) are available.
public void CreateChatCompletion(
Message message, // Always the first parameter.
List<ChatCompletionMessage> messages,
string model,
// ... other parameters ...
)
{
// Construct and send the chat completion request using the message.
this.Send(message, new ChatCompletionRequest(REST.RequestTypeType.Create)
{
Messages = messages,
Model = model ?? "llama-3.1-8b-instant",
// ... additional settings ...
});
}
¶ 5. Component State Lifecycle
Fuse components follow a structured runtime lifecycle. These states allow the platform to apply governance, resource management, and observability at each phase of execution.
Whether used in development or production environments, component lifecycle methods help developers manage setup, teardown, retry, and fault scenarios in a controlled, traceable way.
When an instance of a Fuse component is added to a pipeline, it can exist in different states throughout its lifecycle. The state of the component can be determined using the State property, while the IsActive property indicates whether the component is active and running.
The State property may be assigned one of the following values:
- Uninitialized (0): Indicates the component is uninitialized.
- Stopped (1): Indicates the component is stopped.
- Initializing (2): Indicates the component is initializing.
- Initialized (4): Indicates the component is initialized.
- Starting (8): Indicates the component is starting.
- Started (16): Indicates the component is running.
- Stopping (32): Indicates the component is stopping.
- Pausing (64): Indicates the component is pausing.
- Paused (128): Indicates the component is paused.
- Resuming (256): Indicates the component is resuming from a previous pause.
- Disposing (512): Indicates the component is disposing.
- Disposed (1024): Indicates the component was disposed.
- Error (2048): Indicates the component experienced an error.
At runtime, developers may need to execute custom code during these lifecycle events. For example, some operations might be required to set initial variables when the component is initialized or to free resources when the component is disposed during system shutdown.
The following class methods can be overridden to handle these lifecycle events:
- OnSignal(): Occurs when the runtime environment performs a signal check to the component instance.
- OnInitialize(): Occurs during the component instance initialization process.
- OnStart(): Occurs when the component instance starts.
- OnPause(): Occurs when the component instance is pausing.
- OnResume(): Occurs when the component instance resumes from a pause.
- OnStop(bool gracefully): Occurs when the component instance is stopped. The
gracefullyparameter istrueif the component stops gracefully. - OnDispose(): Occurs when the component instance is shut down, allowing for resource cleanup.
Example:
```csharp
/// <summary>Use this adapter to perform string operations against the message payload.</summary>
[Component(
Name = "Strings",
Category = "Data",
Description = "Use this adapter to perform transformation operations against a string message payload.",
UIIconSID = "fal fa-font",
IconColor = "#4169E1"
)]
public class Strings : Component
{
// Component implementation...
/// <summary>Occurs when the runtime environment perform a signal check to the component instance.</summary>
public override void OnSignal()
{
base.OnSignal();
}
/// <summary>Occurs during the process instance initialization.</summary>
public override void OnInitialize()
{
// Set initial variables and perform setup tasks...
base.OnInitialize();
}
/// <summary>Occurs when the component instance is shutdown.</summary>
public override void OnDispose()
{
// Free resources and perform cleanup operations...
base.OnDispose();
}
}
¶ 6. Deployment and Registration Process
After your Fuse components are built and properly annotated, they need to be deployed and registered with the Fuse platform. During installation, Fuse scans all assemblies for classes decorated with attributes such as [Component], [Method], [MethodArgument] and [Property]. The metadata gathered from these annotations is then used to register your components and make them available for building pipeline processes and flows.
For more details on the deployment and registration process, please refer to our Deployment and Registration Process page.
¶ 7. Versioning
Versioning of Fuse components is handled at the assembly or project level. It is crucial to manage and update versions properly to ensure compatibility and smooth upgrades across your Fuse environment.
For an in-depth discussion on versioning best practices and managing project-level versioning for Fuse components, please see our Versioning Guidelines page.
¶ 8. Deprecation Guidelines
When marking components, methods, or properties as deprecated, follow these guidelines:
-
Components:
Use theOptionsproperty in the[Component]attribute and set it toComponentTypeOptionsType.Deprecatedto mark an entire component as deprecated.Example:
[Component( Name = "Old Component", Options = ComponentTypeOptionsType.Deprecated, Description = "This component is deprecated. Use the NewComponent instead." )] public class OldComponent : Component { // Implementation... } -
Methods:
Set theOptionsproperty in the[Method]attribute toMethodOptionType.Deprecatedto mark a method as deprecated.Example:
[Method( Text = "Old Method", Description = "This method is deprecated. Use NewMethod instead.", Options = MethodOptionType.Deprecated )] public void OldMethod(Message message) { // Implementation... } -
Properties:
For deprecated properties, include thePropertyOptionType.Deprecatedflag in theOptionsproperty of the[Property]attribute.Example:
[Property( Text = "Old Property", Options = PropertyOptionType.Deprecated, Description = "This property is deprecated. Use NewProperty instead." )] public string OldProperty { get; set; }
Additionally, use the DeprecationNotes property (available in both MemberAttribute and PropertyAttribute) to provide any notes or guidance regarding the deprecation.
¶ 9. Best Practices
-
Annotate Every External Member:
Every property, method, and method argument must be decorated with the appropriate custom attributes. This metadata is essential for Fuse to register and integrate your components properly. -
Detailed XML Documentation:
Provide complete XML comments for all methods and parameters. Detailed documentation helps both in understanding the component’s functionality and in generating clear client-side definitions. -
Consistent Naming Conventions:
Use clear, descriptive names for components, methods, and properties to facilitate easier discovery, maintenance, and integration. -
Utilize Provided Enumerations:
Leverage enums such asComponentTypeType,MethodTypeType, andMethodOptionTypeto precisely configure your component’s behavior. -
Modular Code Organization:
For components with multiple functionalities, use partial classes to split the code into logical files. This enhances maintainability and clarity. -
Thorough Testing:
Test your component with all expected payload types (e.g., byte arrays, streams, file streams) and ensure that every annotated parameter is processed correctly by the Fuse runtime.
¶ 10. Conclusion
This guide outlines how to create governed, discoverable, and reusable components for the eTag Fuse platform. Fuse Components are not just technical artifacts — they are interoperability primitives that participate in orchestrated, policy-aware execution.
By applying the correct annotations and structuring your logic around supported patterns, you help ensure that your components can:
- Be reused across pipelines and tenants
- Support declarative orchestration
- Adapt to new domains and integration scenarios
- Remain secure, observable, and governed by design
Whether building API connectors, internal logic steps, or data transformers, Fuse empowers you to contribute to a consistent, auditable execution model built for interoperability at scale.