ultravisor 1.0.3 → 1.0.8

package/source/services/tasks/flow-control/Ultravisor-TaskType-SplitExecute.cjs

@@ -0,0 +1,164 @@
+const libTaskTypeBase = require('../Ultravisor-TaskType-Base.cjs');
+
+/**
+ * SplitExecute Task Type
+ *
+ * Splits an input string by a delimiter and fires an event for each token.
+ * Operates as a state machine: each invocation processes exactly one token.
+ *
+ * Flow (driven by graph connections):
+ *   PerformSplit  -> split input, store tokens, emit first token via TokenDataSent
+ *   StepComplete  -> advance to next token, emit via TokenDataSent
+ *                    (or fire CompletedAllSubtasks when all tokens are done)
+ *
+ * The loop is driven by explicit graph connections:
+ *   SplitExecute.TokenDataSent -> downstream tasks -> ... -> SplitExecute.StepComplete
+ *
+ * State is persisted between invocations in TaskOutputs[NodeHash]:
+ *   _Tokens        {Array}  - the split token array (internal)
+ *   CurrentToken   {string} - the current token being processed
+ *   TokenIndex     {number} - 0-based index of the current token
+ *   TokenCount     {number} - total number of tokens
+ *   CompletedCount {number} - number of tokens fully processed
+ */
+class UltravisorTaskTypeSplitExecute extends libTaskTypeBase
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'UltravisorTaskTypeSplitExecute';
+	}
+
+	get definition()
+	{
+		return require('./definitions/split-execute.json');
+	}
+
+	execute(pResolvedSettings, pExecutionContext, fCallback, fFireIntermediateEvent)
+	{
+		let tmpTriggeringEvent = pExecutionContext.TriggeringEventName;
+
+		if (tmpTriggeringEvent === 'StepComplete')
+		{
+			return this._handleStepComplete(pExecutionContext, fCallback);
+		}
+
+		// Default: PerformSplit (initial trigger)
+		return this._handlePerformSplit(pResolvedSettings, pExecutionContext, fCallback);
+	}
+
+	/**
+	 * Handle the PerformSplit event: split input and emit the first token.
+	 */
+	_handlePerformSplit(pResolvedSettings, pExecutionContext, fCallback)
+	{
+		let tmpInputString = pResolvedSettings.InputString;
+		let tmpDelimiter = pResolvedSettings.SplitDelimiter;
+
+		if (typeof(tmpInputString) !== 'string')
+		{
+			return fCallback(null, {
+				EventToFire: 'Error',
+				Outputs: { CurrentToken: '', TokenIndex: 0, TokenCount: 0, CompletedCount: 0 },
+				Log: ['InputString is not a string.']
+			});
+		}
+
+		if (tmpDelimiter === undefined || tmpDelimiter === null)
+		{
+			tmpDelimiter = '\n';
+		}
+
+		let tmpTokens = tmpInputString.split(tmpDelimiter);
+		if (pResolvedSettings.TrimTokens)
+		{
+			tmpTokens = tmpTokens.map(function (pT) { return pT.trim(); });
+		}
+		if (pResolvedSettings.SkipEmpty)
+		{
+			tmpTokens = tmpTokens.filter(function (pT) { return pT.length > 0; });
+		}
+		let tmpTokenCount = tmpTokens.length;
+		let tmpLog = [`Splitting input (${tmpInputString.length} chars) by "${tmpDelimiter}" into ${tmpTokenCount} tokens.`];
+
+		if (tmpTokenCount === 0)
+		{
+			return fCallback(null, {
+				EventToFire: 'CompletedAllSubtasks',
+				Outputs: { CurrentToken: '', TokenIndex: 0, TokenCount: 0, CompletedCount: 0 },
+				Log: tmpLog.concat(['No tokens to process.'])
+			});
+		}
+
+		let tmpFirstToken = tmpTokens[0];
+		tmpLog.push(`Emitting token 1/${tmpTokenCount}: "${tmpFirstToken.substring(0, 50)}"`);
+
+		return fCallback(null, {
+			EventToFire: 'TokenDataSent',
+			Outputs: {
+				_Tokens: tmpTokens,
+				CurrentToken: tmpFirstToken,
+				TokenIndex: 0,
+				TokenCount: tmpTokenCount,
+				CompletedCount: 0
+			},
+			Log: tmpLog
+		});
+	}
+
+	/**
+	 * Handle the StepComplete event: advance to the next token or finish.
+	 */
+	_handleStepComplete(pExecutionContext, fCallback)
+	{
+		let tmpStoredState = pExecutionContext.TaskOutputs[pExecutionContext.NodeHash] || {};
+		let tmpTokens = tmpStoredState._Tokens;
+
+		if (!Array.isArray(tmpTokens))
+		{
+			return fCallback(null, {
+				EventToFire: 'Error',
+				Outputs: { CurrentToken: '', TokenIndex: 0, TokenCount: 0, CompletedCount: 0 },
+				Log: ['StepComplete received but no stored tokens found. Was PerformSplit called first?']
+			});
+		}
+
+		let tmpTokenCount = tmpTokens.length;
+		let tmpPreviousIndex = tmpStoredState.TokenIndex || 0;
+		let tmpCompletedCount = (tmpStoredState.CompletedCount || 0) + 1;
+		let tmpNextIndex = tmpPreviousIndex + 1;
+
+		if (tmpNextIndex >= tmpTokenCount)
+		{
+			// All tokens processed
+			return fCallback(null, {
+				EventToFire: 'CompletedAllSubtasks',
+				Outputs: {
+					_Tokens: tmpTokens,
+					CurrentToken: tmpTokens[tmpTokenCount - 1],
+					TokenIndex: tmpTokenCount - 1,
+					TokenCount: tmpTokenCount,
+					CompletedCount: tmpCompletedCount
+				},
+				Log: [`All ${tmpTokenCount} tokens processed (${tmpCompletedCount} completed).`]
+			});
+		}
+
+		let tmpNextToken = tmpTokens[tmpNextIndex];
+
+		return fCallback(null, {
+			EventToFire: 'TokenDataSent',
+			Outputs: {
+				_Tokens: tmpTokens,
+				CurrentToken: tmpNextToken,
+				TokenIndex: tmpNextIndex,
+				TokenCount: tmpTokenCount,
+				CompletedCount: tmpCompletedCount
+			},
+			Log: [`Emitting token ${tmpNextIndex + 1}/${tmpTokenCount}: "${tmpNextToken.substring(0, 50)}"`]
+		});
+	}
+}
+
+module.exports = UltravisorTaskTypeSplitExecute;

package/source/services/tasks/flow-control/definitions/if-conditional.json

@@ -0,0 +1,25 @@
+{
+	"Hash": "if-conditional",
+	"Type": "if-conditional",
+	"Name": "If Conditional",
+	"Description": "Evaluates a condition and branches execution to True or False.",
+	"Category": "control",
+	"Capability": "Flow Control",
+	"Action": "Branch",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Evaluate" }],
+	"EventOutputs": [
+		{ "Name": "True" },
+		{ "Name": "False" }
+	],
+	"SettingsInputs": [
+		{ "Name": "DataAddress", "DataType": "String", "Required": false },
+		{ "Name": "CompareValue", "DataType": "String", "Required": false },
+		{ "Name": "Operator", "DataType": "String", "Required": false },
+		{ "Name": "Expression", "DataType": "String", "Required": false }
+	],
+	"StateOutputs": [
+		{ "Name": "Result", "DataType": "Boolean" }
+	],
+	"DefaultSettings": { "DataAddress": "", "CompareValue": "", "Operator": "==", "Expression": "" }
+}

package/source/services/tasks/flow-control/definitions/launch-operation.json

@@ -0,0 +1,27 @@
+{
+	"Hash": "launch-operation",
+	"Type": "launch-operation",
+	"Name": "Launch Operation",
+	"Description": "Executes a child operation by hash, with isolated operation state.",
+	"Category": "control",
+	"Capability": "Flow Control",
+	"Action": "LaunchOperation",
+	"Tier": "Engine",
+	"EventInputs": [{ "Name": "Launch" }],
+	"EventOutputs": [
+		{ "Name": "Completed" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "OperationHash", "DataType": "String", "Required": true },
+		{ "Name": "InputData", "DataType": "String" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Maximum execution time for the child operation in milliseconds (0 = unlimited)" },
+		{ "Name": "InheritGlobalState", "DataType": "Boolean", "Required": false, "Description": "Copy parent GlobalState into child operation (default true)" }
+	],
+	"StateOutputs": [
+		{ "Name": "Result", "DataType": "String" },
+		{ "Name": "Status", "DataType": "String" },
+		{ "Name": "ElapsedMs", "DataType": "Number" }
+	],
+	"DefaultSettings": { "OperationHash": "", "InputData": "", "TimeoutMs": 0, "InheritGlobalState": true }
+}

package/source/services/tasks/flow-control/definitions/split-execute.json

@@ -0,0 +1,32 @@
+{
+	"Hash": "split-execute",
+	"Type": "split-execute",
+	"Name": "Split Execute",
+	"Description": "Splits a string by delimiter and processes each token through a sub-graph.",
+	"Category": "control",
+	"Capability": "Flow Control",
+	"Action": "Iterate",
+	"Tier": "Engine",
+	"EventInputs": [
+		{ "Name": "PerformSplit" },
+		{ "Name": "StepComplete" }
+	],
+	"EventOutputs": [
+		{ "Name": "TokenDataSent" },
+		{ "Name": "CompletedAllSubtasks" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "InputString", "DataType": "String", "Required": true },
+		{ "Name": "SplitDelimiter", "DataType": "String", "Required": true },
+		{ "Name": "SkipEmpty", "DataType": "Boolean", "Required": false, "Description": "Skip empty tokens after splitting" },
+		{ "Name": "TrimTokens", "DataType": "Boolean", "Required": false, "Description": "Trim whitespace from each token" }
+	],
+	"StateOutputs": [
+		{ "Name": "CurrentToken", "DataType": "String" },
+		{ "Name": "TokenIndex", "DataType": "Number" },
+		{ "Name": "TokenCount", "DataType": "Number" },
+		{ "Name": "CompletedCount", "DataType": "Number" }
+	],
+	"DefaultSettings": { "InputString": "", "SplitDelimiter": "\n", "SkipEmpty": false, "TrimTokens": false }
+}

package/source/services/tasks/http-client/Ultravisor-TaskConfigs-HttpClient.cjs

@@ -0,0 +1,281 @@
+/**
+ * Task configurations for the "HTTP Client" capability.
+ *
+ * General-purpose REST / HTTP request tasks.
+ *
+ * Contains:
+ *   - get-json        — Performs an HTTP GET request and parses the response as JSON.
+ *   - get-text        — Performs an HTTP GET request and returns the response as text.
+ *   - send-json       — Sends JSON data via HTTP POST or PUT.
+ *   - rest-request    — Performs a fully configurable HTTP REST request.
+ */
+
+
+// ── Module-scoped helpers ───────────────────────────────────────────
+
+/**
+ * Get a service instance from the fable services map.
+ */
+function _getService(pTask, pTypeName)
+{
+	if (pTask.fable.servicesMap[pTypeName])
+	{
+		return Object.values(pTask.fable.servicesMap[pTypeName])[0];
+	}
+	return null;
+}
+
+/**
+ * Parse headers from a JSON string or return empty object.
+ */
+function _parseHeaders(pHeadersString)
+{
+	if (!pHeadersString || typeof(pHeadersString) !== 'string' || pHeadersString.trim().length === 0)
+	{
+		return {};
+	}
+
+	try
+	{
+		let tmpHeaders = JSON.parse(pHeadersString);
+		if (typeof(tmpHeaders) === 'object' && tmpHeaders !== null)
+		{
+			return tmpHeaders;
+		}
+	}
+	catch (pError)
+	{
+		// Not valid JSON — ignore
+	}
+
+	return {};
+}
+
+
+module.exports =
+[
+	// ── get-json ───────────────────────────────────────────────
+	{
+		Definition: require('./definitions/get-json.json'),
+		Execute: function (pTask, pResolvedSettings, pExecutionContext, fCallback)
+		{
+			let tmpURL = pResolvedSettings.URL || '';
+			if (!tmpURL)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['GetJSON: no URL specified.'] });
+			}
+
+			let tmpRestClient = _getService(pTask, 'RestClient');
+			if (!tmpRestClient)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['GetJSON: RestClient service not found.'] });
+			}
+
+			let tmpRequestOptions = { url: tmpURL, headers: _parseHeaders(pResolvedSettings.Headers), timeout: pResolvedSettings.TimeoutMs || 30000 };
+
+			tmpRestClient.getJSON(tmpRequestOptions,
+				function (pError, pResponse, pData)
+				{
+					if (pError)
+					{
+						return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: [`GetJSON: request failed: ${pError.message}`] });
+					}
+
+					let tmpStateWrites = {};
+					if (pResolvedSettings.Destination)
+					{
+						tmpStateWrites[pResolvedSettings.Destination] = pData;
+					}
+
+					return fCallback(null, {
+						EventToFire: 'Complete',
+						Outputs: { Data: pData, StatusCode: (pResponse && pResponse.statusCode) ? pResponse.statusCode : 0 },
+						StateWrites: tmpStateWrites,
+						Log: [`GetJSON: received response from ${tmpURL}`]
+					});
+				});
+		}
+	},
+
+	// ── get-text ───────────────────────────────────────────────
+	{
+		Definition: require('./definitions/get-text.json'),
+		Execute: function (pTask, pResolvedSettings, pExecutionContext, fCallback)
+		{
+			let tmpURL = pResolvedSettings.URL || '';
+			if (!tmpURL)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['GetText: no URL specified.'] });
+			}
+
+			let tmpRestClient = _getService(pTask, 'RestClient');
+			if (!tmpRestClient)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['GetText: RestClient service not found.'] });
+			}
+
+			let tmpRequestOptions = { url: tmpURL, headers: _parseHeaders(pResolvedSettings.Headers), timeout: pResolvedSettings.TimeoutMs || 30000 };
+
+			tmpRestClient.getRawText(tmpRequestOptions,
+				function (pError, pResponse, pData)
+				{
+					if (pError)
+					{
+						return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: [`GetText: request failed: ${pError.message}`] });
+					}
+
+					let tmpStateWrites = {};
+					if (pResolvedSettings.Destination)
+					{
+						tmpStateWrites[pResolvedSettings.Destination] = pData;
+					}
+
+					return fCallback(null, {
+						EventToFire: 'Complete',
+						Outputs: { Data: pData, StatusCode: (pResponse && pResponse.statusCode) ? pResponse.statusCode : 0 },
+						StateWrites: tmpStateWrites,
+						Log: [`GetText: received ${(pData || '').length} chars from ${tmpURL}`]
+					});
+				});
+		}
+	},
+
+	// ── send-json ──────────────────────────────────────────────
+	{
+		Definition: require('./definitions/send-json.json'),
+		Execute: function (pTask, pResolvedSettings, pExecutionContext, fCallback)
+		{
+			let tmpURL = pResolvedSettings.URL || '';
+			if (!tmpURL)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['SendJSON: no URL specified.'] });
+			}
+
+			let tmpRestClient = _getService(pTask, 'RestClient');
+			if (!tmpRestClient)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['SendJSON: RestClient service not found.'] });
+			}
+
+			let tmpDataAddress = pResolvedSettings.DataAddress || '';
+			let tmpBody = {};
+			if (tmpDataAddress && pExecutionContext.StateManager)
+			{
+				tmpBody = pExecutionContext.StateManager.resolveAddress(tmpDataAddress, pExecutionContext, pExecutionContext.NodeHash);
+				if (typeof(tmpBody) !== 'object') { tmpBody = { value: tmpBody }; }
+			}
+
+			let tmpMethod = (pResolvedSettings.Method || 'POST').toUpperCase();
+			let tmpOptions = { url: tmpURL, body: tmpBody, headers: _parseHeaders(pResolvedSettings.Headers), timeout: pResolvedSettings.TimeoutMs || 30000 };
+
+			let tmpDoRequest = (tmpMethod === 'PUT') ? tmpRestClient.putJSON.bind(tmpRestClient) : tmpRestClient.postJSON.bind(tmpRestClient);
+
+			tmpDoRequest(tmpOptions,
+				function (pError, pResponse, pData)
+				{
+					if (pError)
+					{
+						return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: [`SendJSON: request failed: ${pError.message}`] });
+					}
+
+					let tmpStateWrites = {};
+					if (pResolvedSettings.Destination)
+					{
+						tmpStateWrites[pResolvedSettings.Destination] = pData;
+					}
+
+					return fCallback(null, {
+						EventToFire: 'Complete',
+						Outputs: { Response: pData, StatusCode: (pResponse && pResponse.statusCode) ? pResponse.statusCode : 0 },
+						StateWrites: tmpStateWrites,
+						Log: [`SendJSON: ${tmpMethod} to ${tmpURL} complete`]
+					});
+				});
+		}
+	},
+
+	// ── rest-request ───────────────────────────────────────────
+	{
+		Definition: require('./definitions/rest-request.json'),
+		Execute: function (pTask, pResolvedSettings, pExecutionContext, fCallback)
+		{
+			let tmpURL = pResolvedSettings.URL || '';
+			if (!tmpURL)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['RestRequest: no URL specified.'] });
+			}
+
+			let tmpRestClient = _getService(pTask, 'RestClient');
+			if (!tmpRestClient)
+			{
+				return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: ['RestRequest: RestClient service not found.'] });
+			}
+
+			let tmpMethod = (pResolvedSettings.Method || 'GET').toUpperCase();
+			let tmpHeaders = _parseHeaders(pResolvedSettings.Headers);
+			if (pResolvedSettings.ContentType)
+			{
+				tmpHeaders['Content-Type'] = pResolvedSettings.ContentType;
+			}
+
+			let tmpRequestOptions = { url: tmpURL, method: tmpMethod, headers: tmpHeaders, timeout: pResolvedSettings.TimeoutMs || 30000 };
+
+			// Parse body for non-GET methods
+			if (tmpMethod !== 'GET' && pResolvedSettings.Body)
+			{
+				try
+				{
+					tmpRequestOptions.body = JSON.parse(pResolvedSettings.Body);
+				}
+				catch (pParseError)
+				{
+					tmpRequestOptions.body = pResolvedSettings.Body;
+				}
+			}
+
+			let tmpRetryDelayMs = pResolvedSettings.RetryDelayMs || 1000;
+
+			function _doRequest(pRetriesLeft)
+			{
+				tmpRestClient.executeChunkedRequest(tmpRequestOptions,
+					function (pError, pResponse, pData)
+					{
+						if (pError)
+						{
+							if (pRetriesLeft > 0)
+							{
+								return setTimeout(function () { _doRequest(pRetriesLeft - 1); }, tmpRetryDelayMs);
+							}
+							return fCallback(null, { EventToFire: 'Error', Outputs: {}, Log: [`RestRequest: ${tmpMethod} ${tmpURL} failed: ${pError.message}`] });
+						}
+
+						// Try to parse as JSON, fall back to raw string
+						let tmpParsedData = pData;
+						try
+						{
+							tmpParsedData = JSON.parse(pData);
+						}
+						catch (pParseError)
+						{
+							// keep raw string
+						}
+
+						let tmpStateWrites = {};
+						if (pResolvedSettings.Destination)
+						{
+							tmpStateWrites[pResolvedSettings.Destination] = tmpParsedData;
+						}
+
+						return fCallback(null, {
+							EventToFire: 'Complete',
+							Outputs: { Response: tmpParsedData, StatusCode: (pResponse && pResponse.statusCode) ? pResponse.statusCode : 0, ResponseHeaders: (pResponse && pResponse.headers) ? JSON.stringify(pResponse.headers) : '{}' },
+							StateWrites: tmpStateWrites,
+							Log: [`RestRequest: ${tmpMethod} ${tmpURL} -> ${pResponse ? pResponse.statusCode : '?'}`]
+						});
+					});
+			}
+
+			_doRequest(pResolvedSettings.Retries || 0);
+		}
+	}
+];

package/source/services/tasks/http-client/definitions/get-json.json

@@ -0,0 +1,26 @@
+{
+	"Hash": "get-json",
+	"Type": "get-json",
+	"Name": "Get JSON",
+	"Description": "Performs an HTTP GET request and parses the response as JSON.",
+	"Category": "rest",
+	"Capability": "HTTP Client",
+	"Action": "GetJSON",
+	"Tier": "Platform",
+	"EventInputs": [{ "Name": "Trigger" }],
+	"EventOutputs": [
+		{ "Name": "Complete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "URL", "DataType": "String", "Required": true, "Description": "URL to GET" },
+		{ "Name": "Headers", "DataType": "String", "Required": false, "Description": "JSON string of request headers" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store response data" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Request timeout in milliseconds" }
+	],
+	"StateOutputs": [
+		{ "Name": "Data", "DataType": "Object", "Description": "Parsed JSON response" },
+		{ "Name": "StatusCode", "DataType": "Number", "Description": "HTTP response status code" }
+	],
+	"DefaultSettings": { "URL": "", "Headers": "", "Destination": "", "TimeoutMs": 30000 }
+}

package/source/services/tasks/http-client/definitions/get-text.json

@@ -0,0 +1,26 @@
+{
+	"Hash": "get-text",
+	"Type": "get-text",
+	"Name": "Get Text",
+	"Description": "Performs an HTTP GET request and returns the response as text.",
+	"Category": "rest",
+	"Capability": "HTTP Client",
+	"Action": "GetText",
+	"Tier": "Platform",
+	"EventInputs": [{ "Name": "Trigger" }],
+	"EventOutputs": [
+		{ "Name": "Complete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "URL", "DataType": "String", "Required": true, "Description": "URL to GET" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store response text" },
+		{ "Name": "Headers", "DataType": "String", "Required": false, "Description": "JSON string of request headers" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Request timeout in milliseconds" }
+	],
+	"StateOutputs": [
+		{ "Name": "Data", "DataType": "String", "Description": "Response text" },
+		{ "Name": "StatusCode", "DataType": "Number", "Description": "HTTP response status code" }
+	],
+	"DefaultSettings": { "URL": "", "Destination": "", "Headers": "", "TimeoutMs": 30000 }
+}

package/source/services/tasks/http-client/definitions/rest-request.json

@@ -0,0 +1,32 @@
+{
+	"Hash": "rest-request",
+	"Type": "rest-request",
+	"Name": "REST Request",
+	"Description": "Performs a fully configurable HTTP REST request.",
+	"Category": "rest",
+	"Capability": "HTTP Client",
+	"Action": "Request",
+	"Tier": "Platform",
+	"EventInputs": [{ "Name": "In" }],
+	"EventOutputs": [
+		{ "Name": "Complete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "URL", "DataType": "String", "Required": true, "Description": "URL to request" },
+		{ "Name": "Method", "DataType": "String", "Required": false, "Description": "HTTP method (GET, POST, PUT, DELETE, etc.)" },
+		{ "Name": "ContentType", "DataType": "String", "Required": false, "Description": "Content-Type header" },
+		{ "Name": "Headers", "DataType": "String", "Required": false, "Description": "JSON string of request headers" },
+		{ "Name": "Body", "DataType": "String", "Required": false, "Description": "Request body (JSON string or raw text)" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store response" },
+		{ "Name": "Retries", "DataType": "Number", "Required": false, "Description": "Number of retries on failure" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Request timeout in milliseconds" },
+		{ "Name": "RetryDelayMs", "DataType": "Number", "Required": false, "Description": "Delay between retry attempts in milliseconds" }
+	],
+	"StateOutputs": [
+		{ "Name": "Response", "DataType": "Object", "Description": "Response data" },
+		{ "Name": "StatusCode", "DataType": "Number", "Description": "HTTP response status code" },
+		{ "Name": "ResponseHeaders", "DataType": "String", "Description": "JSON string of response headers" }
+	],
+	"DefaultSettings": { "URL": "", "Method": "GET", "ContentType": "application/json", "Headers": "", "Body": "", "Destination": "", "Retries": 0, "TimeoutMs": 30000, "RetryDelayMs": 1000 }
+}

package/source/services/tasks/http-client/definitions/send-json.json

@@ -0,0 +1,28 @@
+{
+	"Hash": "send-json",
+	"Type": "send-json",
+	"Name": "Send JSON",
+	"Description": "Sends JSON data via HTTP POST or PUT.",
+	"Category": "rest",
+	"Capability": "HTTP Client",
+	"Action": "SendJSON",
+	"Tier": "Platform",
+	"EventInputs": [{ "Name": "Trigger" }],
+	"EventOutputs": [
+		{ "Name": "Complete" },
+		{ "Name": "Error", "IsError": true }
+	],
+	"SettingsInputs": [
+		{ "Name": "URL", "DataType": "String", "Required": true, "Description": "URL to send data to" },
+		{ "Name": "Method", "DataType": "String", "Required": false, "Description": "HTTP method (POST or PUT)" },
+		{ "Name": "DataAddress", "DataType": "String", "Required": false, "Description": "State address of the data to send" },
+		{ "Name": "Headers", "DataType": "String", "Required": false, "Description": "JSON string of request headers" },
+		{ "Name": "Destination", "DataType": "String", "Required": false, "Description": "State address to store response" },
+		{ "Name": "TimeoutMs", "DataType": "Number", "Required": false, "Description": "Request timeout in milliseconds" }
+	],
+	"StateOutputs": [
+		{ "Name": "Response", "DataType": "Object", "Description": "Response data" },
+		{ "Name": "StatusCode", "DataType": "Number", "Description": "HTTP response status code" }
+	],
+	"DefaultSettings": { "URL": "", "Method": "POST", "DataAddress": "", "Headers": "", "Destination": "", "TimeoutMs": 30000 }
+}