total5 0.0.17-7 → 0.0.17-9

package/aimodel.js

@@ -235,17 +235,167 @@ function createTool(id, name) {
 	};
 }
 
+function parseJSON(value) {
+	try {
+		return JSON.parse(value);
+	} catch (e) {
+		return null;
+	}
+}
+
+function createTool(id, name) {
+	return {
+		id: id || null,
+		name: name || null,
+		arguments: '',
+		input: null
+	};
+}
+
+function normalize(value) {
+
+	if (value == null)
+		return {};
+
+	if (typeof value === 'object')
+		return value;
+
+	if (typeof value !== 'string')
+		return value;
+
+	value = value.trim();
+
+	if (!value)
+		return {};
+
+	const json = parseJSON(value);
+
+	if (json)
+		return json;
+
+	return value;
+}
+
+function parseJSON(value) {
+	try {
+		return JSON.parse(value);
+	} catch (e) {
+		return null;
+	}
+}
+
+function createTool(id, name) {
+	return {
+		id: id || null,
+		name: name || null,
+		arguments: '',
+		input: null
+	};
+}
+
+function normalize(value) {
+
+	if (value == null)
+		return {};
+
+	if (typeof value === 'object')
+		return value;
+
+	if (typeof value !== 'string')
+		return value;
+
+	value = value.trim();
+
+	if (!value)
+		return {};
+
+	const json = parseJSON(value);
+
+	if (json)
+		return json;
+
+	return value;
+}
+
 class AIStreamParser {
 
-	constructor(provider) {
+	constructor(provider, ondata) {
 		this.provider = provider || 'generic';
+
 		this.content = '';
+		this.thinking = '';
 		this.tools = [];
 		this.reasoning = 'content';
+
 		this.buffer = Buffer.alloc(0);
 		this.toolmap = Object.create(null);
+
+		this.listeners = Object.create(null);
+		this.ondata = typeof ondata === 'function' ? ondata : null;
+
+		this.thinking_signature = null;
+		this.thought_signatures = [];
+	}
+
+	// ------------------------------------------------------------
+	// Events
+	// ------------------------------------------------------------
+
+	on(type, fn) {
+		if (!type || typeof fn !== 'function')
+			return this;
+
+		if (!this.listeners[type])
+			this.listeners[type] = [];
+
+		this.listeners[type].push(fn);
+		return this;
 	}
 
+	off(type, fn) {
+		const arr = this.listeners[type];
+
+		if (!arr)
+			return this;
+
+		const index = arr.indexOf(fn);
+
+		if (index !== -1)
+			arr.splice(index, 1);
+
+		return this;
+	}
+
+	emit(type, data) {
+		const event = {
+			type,
+			...data
+		};
+
+		if (this.ondata)
+			this.ondata(event);
+
+		const listeners = this.listeners[type];
+
+		if (listeners) {
+			for (const fn of listeners)
+				fn(event);
+		}
+
+		const all = this.listeners['*'];
+
+		if (all) {
+			for (const fn of all)
+				fn(event);
+		}
+
+		return event;
+	}
+
+	// ------------------------------------------------------------
+	// Public API
+	// ------------------------------------------------------------
+
 	write(chunk) {
 		if (chunk == null)
 			return this.output();
@@ -265,11 +415,11 @@ class AIStreamParser {
 
 		let index;
 
-		while ((index = this.buffer.indexOf(0x0A)) !== -1) { // \n
+		while ((index = this.buffer.indexOf(0x0A)) !== -1) {
 			let lineBuffer = this.buffer.subarray(0, index);
 			this.buffer = this.buffer.subarray(index + 1);
 
-			// CRLF support: remove \r
+			// CRLF support
 			if (lineBuffer.length && lineBuffer[lineBuffer.length - 1] === 0x0D)
 				lineBuffer = lineBuffer.subarray(0, lineBuffer.length - 1);
 
@@ -311,6 +461,7 @@ class AIStreamParser {
 			return;
 
 		const json = parseJSON(line);
+
 		if (json)
 			this.writeObject(json);
 	}
@@ -318,9 +469,17 @@ class AIStreamParser {
 	end() {
 		if (this.buffer.length)
 			this.processLineBuffer(this.buffer);
+
 		this.buffer = Buffer.alloc(0);
 		this.finalizeTools();
-		return this.output();
+
+		const output = this.output();
+
+		this.emit('done', {
+			output
+		});
+
+		return output;
 	}
 
 	writeObject(chunk) {
@@ -328,17 +487,21 @@ class AIStreamParser {
 			case 'ollama':
 				this.parseOllama(chunk);
 				break;
+
 			case 'openai_chat':
 			case 'openai':
 				this.parseOpenAI(chunk);
 				break;
+
 			case 'openai_responses':
 				this.parseOpenAIresponse(chunk);
 				break;
+
 			case 'claude':
 			case 'anthropic':
 				this.parseClaude(chunk);
 				break;
+
 			case 'gemini':
 			case 'google':
 				this.parseGemini(chunk);
@@ -348,26 +511,85 @@ class AIStreamParser {
 				this.parseGeneric(chunk);
 				break;
 		}
+
 		return this.output();
 	}
 
+	// ------------------------------------------------------------
+	// Accumulators
+	// ------------------------------------------------------------
+
 	addContent(value) {
 		if (!value)
 			return;
+
+		if (typeof value !== 'string')
+			value = String(value);
+
 		this.content += value;
+
+		this.emit('content', {
+			delta: value,
+			content: this.content,
+			reasoning: 'content'
+		});
+
 		if (!this.tools.length)
 			this.reasoning = 'content';
 	}
 
+	addThinking(value) {
+		if (!value)
+			return;
+
+		if (typeof value === 'object') {
+
+			if (Array.isArray(value)) {
+				for (const item of value)
+					this.addThinking(item);
+				return;
+			}
+
+			if (value.text != null)
+				value = value.text;
+			else if (value.summary != null)
+				value = value.summary;
+			else if (value.content != null)
+				value = value.content;
+			else if (value.value != null)
+				value = value.value;
+			else
+				value = JSON.stringify(value);
+		}
+
+		if (!value)
+			return;
+
+		if (typeof value !== 'string')
+			value = String(value);
+
+		this.thinking += value;
+		this.reasoning = 'thinking';
+
+		this.emit('thinking', {
+			delta: value,
+			thinking: this.thinking,
+			reasoning: 'thinking'
+		});
+	}
+
 	getTool(key, id, name) {
 
 		key = key || id || name || String(this.tools.length);
 
 		let tool = this.toolmap[key];
+		let isnew = false;
+
 		if (!tool) {
 			tool = createTool(id, name);
 			this.toolmap[key] = tool;
 			this.tools.push(tool);
+			isnew = true;
 		}
 
 		if (id)
@@ -378,6 +600,11 @@ class AIStreamParser {
 
 		this.reasoning = 'tool';
 
+		this.emit(isnew ? 'tool_start' : 'tool_update', {
+			tool: this.cloneTool(tool),
+			reasoning: 'tool'
+		});
+
 		return tool;
 	}
 
@@ -389,10 +616,36 @@ class AIStreamParser {
 		if (typeof value === 'object') {
 			tool.input = value;
 			tool.arguments = JSON.stringify(value);
+
+			this.emit('tool_arguments', {
+				tool: this.cloneTool(tool),
+				delta: value,
+				arguments: tool.input,
+				reasoning: 'tool'
+			});
+
 			return;
 		}
 
+		if (typeof value !== 'string')
+			value = String(value);
+
 		tool.arguments += value;
+
+		this.emit('tool_arguments', {
+			tool: this.cloneTool(tool),
+			delta: value,
+			arguments: tool.arguments,
+			reasoning: 'tool'
+		});
+	}
+
+	cloneTool(tool) {
+		return {
+			id: tool.id,
+			name: tool.name,
+			arguments: tool.input || normalize(tool.arguments)
+		};
 	}
 
 	finalizeTools() {
@@ -404,8 +657,10 @@ class AIStreamParser {
 
 	output() {
 		this.finalizeTools();
-		return {
+
+		const output = {
 			content: this.content,
+			thinking: this.thinking,
 			tools: this.tools.map(tool => ({
 				id: tool.id,
 				name: tool.name,
@@ -413,6 +668,14 @@ class AIStreamParser {
 			})),
 			reasoning: this.tools.length ? 'tool' : this.reasoning
 		};
+
+		if (this.thinking_signature)
+			output.thinking_signature = this.thinking_signature;
+
+		if (this.thought_signatures.length)
+			output.thought_signatures = this.thought_signatures;
+
+		return output;
 	}
 
 	// ------------------------------------------------------------
@@ -421,34 +684,80 @@ class AIStreamParser {
 
 	parseOllama(chunk) {
 
+		// Ollama OpenAI-compatible endpoint fallback
+		if (chunk.choices) {
+			this.parseOpenAI(chunk);
+			return;
+		}
+
 		const message = chunk.message || {};
 
+		// /api/chat thinking
+		if (message.thinking)
+			this.addThinking(message.thinking);
+
+		// /api/generate thinking
+		if (chunk.thinking)
+			this.addThinking(chunk.thinking);
+
+		// OpenAI-compatible / model-specific reasoning fields
+		if (message.reasoning_content)
+			this.addThinking(message.reasoning_content);
+
+		if (message.reasoning)
+			this.addThinking(message.reasoning);
+
+		if (message.reasoning_text)
+			this.addThinking(message.reasoning_text);
+
+		// /api/chat content
 		if (message.content)
 			this.addContent(message.content);
 
-		const calls = message.tool_calls || [];
+		// /api/generate content
+		if (chunk.response)
+			this.addContent(chunk.response);
+
+		const calls = message.tool_calls || chunk.tool_calls || [];
 
 		for (let i = 0; i < calls.length; i++) {
 			const call = calls[i];
-			const fn = call.function || {};
+			const fn = call.function || call;
 			const key = call.id || fn.name || `ollama_${i}`;
 
 			const tool = this.getTool(key, call.id, fn.name);
 
 			if (fn.arguments != null)
 				this.appendToolArguments(tool, fn.arguments);
+			else if (fn.args != null)
+				this.appendToolArguments(tool, fn.args);
+			else if (fn.input != null)
+				this.appendToolArguments(tool, fn.input);
 		}
 	}
 
 	// ------------------------------------------------------------
 	// OpenAI Chat Completions stream
 	// ------------------------------------------------------------
+
 	parseOpenAI(chunk) {
 		const choices = chunk.choices || [];
 
 		for (const choice of choices) {
 			const delta = choice.delta || {};
 
+			if (delta.reasoning_content)
+				this.addThinking(delta.reasoning_content);
+
+			if (delta.reasoning)
+				this.addThinking(delta.reasoning);
+
+			if (delta.thinking)
+				this.addThinking(delta.thinking);
+
+			if (delta.reasoning_text)
+				this.addThinking(delta.reasoning_text);
+
 			if (delta.content)
 				this.addContent(delta.content);
 
@@ -473,11 +782,19 @@ class AIStreamParser {
 
 	parseOpenAIresponse(chunk) {
 		switch (chunk.type) {
+
 			case 'response.output_text.delta':
 			case 'response.refusal.delta':
 				this.addContent(chunk.delta);
 				break;
 
+			case 'response.reasoning_summary_text.delta':
+			case 'response.reasoning_text.delta':
+			case 'response.reasoning_summary.delta':
+			case 'response.reasoning.delta':
+				this.addThinking(chunk.delta);
+				break;
+
 			case 'response.function_call_arguments.delta': {
 				const key = chunk.item_id || chunk.call_id || `openai_response_${chunk.output_index || 0}`;
 				const tool = this.getTool(key, chunk.call_id || chunk.item_id, chunk.name);
@@ -489,6 +806,17 @@ class AIStreamParser {
 			case 'response.output_item.added': {
 				const item = chunk.item || {};
 
+				if (item.type === 'reasoning') {
+					if (item.summary)
+						this.addThinking(item.summary);
+
+					if (item.content)
+						this.addThinking(item.content);
+
+					if (item.text)
+						this.addThinking(item.text);
+				}
+
 				if (item.type === 'function_call') {
 					const key = item.id || item.call_id;
 					const tool = this.getTool(key, item.call_id || item.id, item.name);
@@ -503,6 +831,17 @@ class AIStreamParser {
 			case 'response.output_item.done': {
 				const item = chunk.item || {};
 
+				if (item.type === 'reasoning') {
+					if (item.summary)
+						this.addThinking(item.summary);
+
+					if (item.content)
+						this.addThinking(item.content);
+
+					if (item.text)
+						this.addThinking(item.text);
+				}
+
 				if (item.type === 'function_call') {
 					const key = item.id || item.call_id;
 					const tool = this.getTool(key, item.call_id || item.id, item.name);
@@ -525,6 +864,11 @@ class AIStreamParser {
 			case 'content_block_start': {
 				const block = chunk.content_block || {};
 
+				if (block.type === 'thinking') {
+					if (block.thinking)
+						this.addThinking(block.thinking);
+				}
+
 				if (block.type === 'tool_use') {
 					const key = block.id || `claude_${chunk.index || 0}`;
 					const tool = this.getTool(key, block.id, block.name);
@@ -539,6 +883,12 @@ class AIStreamParser {
 			case 'content_block_delta': {
 				const delta = chunk.delta || {};
 
+				if (delta.type === 'thinking_delta')
+					this.addThinking(delta.thinking);
+
+				if (delta.type === 'signature_delta')
+					this.thinking_signature = delta.signature;
+
 				if (delta.type === 'text_delta')
 					this.addContent(delta.text);
 
@@ -576,8 +926,15 @@ class AIStreamParser {
 			for (let i = 0; i < parts.length; i++) {
 				const part = parts[i];
 
-				if (part.text)
-					this.addContent(part.text);
+				if (part.thoughtSignature)
+					this.thought_signatures.push(part.thoughtSignature);
+
+				if (part.text) {
+					if (part.thought)
+						this.addThinking(part.text);
+					else
+						this.addContent(part.text);
+				}
 
 				if (part.functionCall) {
 					const fn = part.functionCall;
@@ -595,6 +952,31 @@ class AIStreamParser {
 	// ------------------------------------------------------------
 
 	parseGeneric(chunk) {
+
+		if (chunk.thinking)
+			this.addThinking(chunk.thinking);
+
+		if (chunk.reasoning)
+			this.addThinking(chunk.reasoning);
+
+		if (chunk.reasoning_content)
+			this.addThinking(chunk.reasoning_content);
+
+		if (chunk.reasoning_text)
+			this.addThinking(chunk.reasoning_text);
+
+		if (chunk.message?.thinking)
+			this.addThinking(chunk.message.thinking);
+
+		if (chunk.message?.reasoning)
+			this.addThinking(chunk.message.reasoning);
+
+		if (chunk.message?.reasoning_content)
+			this.addThinking(chunk.message.reasoning_content);
+
+		if (chunk.message?.reasoning_text)
+			this.addThinking(chunk.message.reasoning_text);
+
 		if (chunk.content)
 			this.addContent(chunk.content);
 
@@ -622,10 +1004,16 @@ class AIStreamParser {
 
 	reset() {
 		this.content = '';
+		this.thinking = '';
 		this.tools = [];
 		this.reasoning = 'content';
+
 		this.buffer = Buffer.alloc(0);
 		this.toolmap = Object.create(null);
+
+		this.thinking_signature = null;
+		this.thought_signatures = [];
+
 		return this;
 	}
 }

package/builders.js

@@ -1339,6 +1339,12 @@ function ActionCaller() {
 	setImmediate(ActionCallerExec, self);
 }
 
+ActionCaller.prototype.config = function(value) {
+	this.options.config = value;
+	return this;
+};
+
+
 ActionCaller.prototype.debug = function() {
 	this.options.debug = true;
 	return this;
@@ -1412,6 +1418,20 @@ ActionCaller.prototype.exec = function() {
 	$.controller = self.controller;
 	$.user = self.options.user;
 	$.config = action.config || EMPTYOBJECT;
+	if (self.options.config) {
+
+		if ($.config === EMPTYOBJECT)
+			$.config = {};
+		else {
+			let tmp = $.config;
+			$.config = {};
+			for (let key in tmp)
+				$.config[key] = tmp[key];
+		}
+
+		for (let key in self.options.config)
+			$.config[key] = self.options.config[key];
+	}
 
 	action.called++;
 

package/changelog.txt

@@ -17,6 +17,12 @@
 - added `AIMODEL.tool(content, [merge])` method
 - added `AIPARSER(provider)` method for parsing AI responses
 - extended `String.prototype` by adding the `String.parseContext()` method to parse a specific text file format
+- added `ACTION().config(obj)` method
+- added a new property `flow.instance.repo = {}` for storing additional data for Flow node instances
+- fixed `Utils.filestreamer()` method
+- improved `Utils.filestreamer()` method by adding percentage
+- fixed sending data to all outputs `$.send(null, [data])` in the FlowStream
+- fixed sending data to all outputs `instance.send(null, [data])` in the FlowStream
 
 ========================
 0.0.16

package/flow-flowstream.js

@@ -9,7 +9,7 @@ if (!global.F)
 
 const W = F.Worker;
 const Fork = F.Child.fork;
-const VERSION = 33;
+const VERSION = 34;
 const NOTIFYPATH = '/notify/';
 
 var isFLOWSTREAMWORKER = false;
@@ -1939,6 +1939,7 @@ function MAKEFLOWSTREAM(meta) {
 			tmp.offset = com.offset;
 			tmp.size = com.size;
 			tmp.meta = com.meta;
+			tmp.repo = com.repo;
 			tmp.schemaid = com.schemaid;
 			tmp.note = com.note;
 			tmp.schema = com.schema;
@@ -1994,6 +1995,7 @@ function MAKEFLOWSTREAM(meta) {
 		data.design = design;
 		data.variables = variables;
 		data.sources = sources;
+		data.flowstream = VERSION;
 		return data;
 	};
 

package/flowstream.js

@@ -77,10 +77,10 @@ MP.emit = function(name, a, b, c, d, e, f, g) {
 	if (!self.$events)
 		return self;
 
-	var evt = self.$events[name];
+	const evt = self.$events[name];
 	if (evt) {
 
-		var clean = false;
+		let clean = false;
 
 		for (var e of evt) {
 			if (e.once)
@@ -89,7 +89,7 @@ MP.emit = function(name, a, b, c, d, e, f, g) {
 		}
 
 		if (clean) {
-			var index = 0;
+			let index = 0;
 			while (true) {
 				if (!evt[index])
 					break;
@@ -116,12 +116,12 @@ MP.emit2 = function(name, a, b, c, d, e, f, g) {
 	if (!self.$events)
 		return self;
 
-	var evt = self.$events[name];
+	const evt = self.$events[name];
 	if (evt) {
 
-		var clean = false;
+		let clean = false;
 
-		for (var e of evt) {
+		for (let e of evt) {
 			if (e.cloned < self.cloned) {
 				if (e.once)
 					clean = true;
@@ -130,9 +130,9 @@ MP.emit2 = function(name, a, b, c, d, e, f, g) {
 		}
 
 		if (clean) {
-			var index = 0;
+			let index = 0;
 			while (true) {
-				var e = evt[index];
+				let e = evt[index];
 				if (!e)
 					break;
 				if (e.cloned < self.cloned) {
@@ -151,10 +151,10 @@ MP.emit2 = function(name, a, b, c, d, e, f, g) {
 };
 
 MP.on = function(name, fn, once) {
-	var self = this;
+	const self = this;
 	if (!self.$events)
 		self.$events = {};
-	var obj = { cloned: self.cloned, fn: fn, once: once };
+	const obj = { cloned: self.cloned, fn: fn, once: once };
 	if (self.$events[name])
 		self.$events[name].push(obj);
 	else
@@ -167,7 +167,7 @@ MP.once = function(name, fn) {
 };
 
 MP.off = function(name, fn) {
-	var self = this;
+	const self = this;
 
 	if (!name) {
 		delete self.$events;
@@ -175,7 +175,7 @@ MP.off = function(name, fn) {
 	}
 
 	if (self.$events) {
-		var evt = self.$events[name];
+		let evt = self.$events[name];
 		if (evt) {
 			if (fn) {
 				evt = evt.remove(n => n.fn === fn);
@@ -189,8 +189,9 @@ MP.off = function(name, fn) {
 
 MP.clone = function() {
 
-	var self = this;
-	var obj = new Message();
+	const self = this;
+	const obj = new Message();
+
 	obj.previd = self.id;
 	obj.$events = self.$events;
 	obj.duration = self.duration;
@@ -218,9 +219,9 @@ MP.clone = function() {
 	obj.ref = self.ref;
 
 	if (obj.$events && obj.$events.timeout) {
-		var index = 0;
+		let index = 0;
 		while (true) {
-			var e = obj.$events.timeout[index];
+			let e = obj.$events.timeout[index];
 			if (e) {
 				if ((e.cloned + 1) < obj.cloned)
 					obj.$events.timeout.splice(index, 1);
@@ -263,9 +264,9 @@ MP.throw = function(a, b, c, d) {
 function variables(str, data, encoding) {
 
 	if (typeof(str) === 'object') {
-		var obj = {};
-		for (var key in str) {
-			var val = str[key];
+		const obj = {};
+		for (let key in str) {
+			let val = str[key];
 			if (typeof(val) === 'string')
 				obj[key] = variables.call(this, val, data, encoding);
 			else
@@ -277,16 +278,16 @@ function variables(str, data, encoding) {
 	if (typeof(str) !== 'string' || str.indexOf('{') === -1)
 		return str;
 
-	var main = this.main ? this.main : this;
+	const main = this.main ? this.main : this;
 
 	if (data == null || data == true)
 		data = this;
 
 	return str.replace(REG_ARGS, function(text) {
 
-		var l = text[1] === '{' ? 2 : 1;
-		var key = text.substring(l, text.length - l).trim();
-		var val = null;
+		const l = text[1] === '{' ? 2 : 1;
+		const key = text.substring(l, text.length - l).trim();
+		let val = null;
 
 		if (main.variables)
 			val = main.variables[key];
@@ -303,7 +304,7 @@ function variables(str, data, encoding) {
 				val = val.substring(0, val.length - 1);
 		}
 
-		var customencoding = typeof(encoding) === 'function';
+		const customencoding = typeof(encoding) === 'function';
 
 		if (!val && data != null && typeof(data) === 'object')
 			val = key.includes('.') ? F.TUtils.get(data, key) : data[key];
@@ -369,7 +370,7 @@ MP.send = function(outputindex, data, clonedata) {
 
 		if (self.instance.connections) {
 			for (let key in self.instance.connections)
-				count += self.send(key);
+				count += self.send(key, data, clonedata);
 		}
 
 		if (!count)
@@ -781,7 +782,7 @@ FP.inc = function(num) {
 
 FP.cleanforce = function() {
 
-	var self = this;
+	const self = this;
 
 	if (self.cleantimeout) {
 		clearTimeout(self.cleantimeout);
@@ -791,21 +792,21 @@ FP.cleanforce = function() {
 	if (!self.meta)
 		return self;
 
-	for (var key in self.meta.flow) {
+	for (let key in self.meta.flow) {
 		if (!BLACKLISTID[key]) {
-			var instance = self.meta.flow[key];
+			const instance = self.meta.flow[key];
 			if (instance.connections) {
 
-				for (var key2 in instance.connections) {
+				for (let key2 in instance.connections) {
 
-					var conns = instance.connections[key2];
-					var rem = {};
+					const conns = instance.connections[key2];
+					const rem = {};
 
-					for (var conn of conns) {
+					for (let conn of conns) {
 						if (conn) {
-							var target = self.meta.flow[conn.id];
+							const target = self.meta.flow[conn.id];
 							if (target) {
-								var com = self.meta.components[target.component];
+								let com = self.meta.components[target.component];
 								if (com) {
 									if (self.strict) {
 										if (target.inputs) {
@@ -821,7 +822,7 @@ FP.cleanforce = function() {
 						}
 					}
 
-					var arr = conns.remove(c => c == null || rem[c.id] === 1);
+					const arr = conns.remove(c => c == null || rem[c.id] === 1);
 					if (arr.length)
 						instance.connections[key2] = arr;
 					else
@@ -831,10 +832,10 @@ FP.cleanforce = function() {
 		}
 	}
 
-	var paused = self.meta.flow.paused;
+	const paused = self.meta.flow.paused;
 	if (paused) {
-		for (var key in paused) {
-			var arr = key.split(D);
+		for (let key in paused) {
+			const arr = key.split(D);
 			// arr[0] type
 			// arr[1] id
 			// arr[2] index
@@ -987,7 +988,6 @@ function newmiddleware(callback) {
 	return self;
 }
 
-
 function newmessage(data) {
 	var self = this;
 	var msg = new Message();
@@ -1047,40 +1047,48 @@ FP.ontrigger = function(outputindex, data, controller, events) {
 
 	// this == instance
 
-	var schema = this;
-	var self = schema.main;
-	var count = 0;
+	const schema = this;
+	const self = schema.main;
+	let count = 0;
 
 	if (self.paused)
 		return count;
 
 	if (schema && schema.ready && schema.component && schema.connections) {
-		var instance = self.meta.components[schema.component];
+
+		const instance = self.meta.components[schema.component];
+
+		if (outputindex == null) {
+			for (let key in schema.connections)
+				count += schema.send(key, data, controller, events);
+			return count;
+		}
+
 		if (instance && instance.connected && !instance.disabled && self.$can(false, schema.id, outputindex)) {
-			var conn = schema.connections[outputindex];
+			const conn = schema.connections[outputindex];
 			if (conn && conn.length) {
 
-				var ts = Date.now();
-				for (var i = 0; i < conn.length; i++) {
+				const ts = Date.now();
+				for (let i = 0; i < conn.length; i++) {
 
-					var m = conn[i];
-					var target = self.meta.flow[m.id];
+					const m = conn[i];
+					const target = self.meta.flow[m.id];
 
 					if (!target || (!target.message && !target['message_' + m.index]) || !self.$can(true, m.id, m.index))
 						continue;
 
-					var com = self.meta.components[target.component];
+					const com = self.meta.components[target.component];
 					if (!com)
 						continue;
 
 					if (target.isdestroyed || (data && data.instance && data.instance.isdestroyed))
 						continue;
 
-					var ismessage = data instanceof Message;
+					const ismessage = data instanceof Message;
 					if (ismessage && m.color && data.color && data.color !== m.color)
 						continue;
 
-					var message = ismessage ? data.clone() : new Message();
+					let message = ismessage ? data.clone() : new Message();
 
 					if (ismessage) {
 
@@ -1396,7 +1404,7 @@ FP.use = function(schema, callback, reinit) {
 
 FP._use = function(schema, callback, reinit, insert) {
 
-	var self = this;
+	let self = this;
 
 	if (self.loading) {
 		setTimeout(use, 200, self, schema, callback, reinit, insert);
@@ -1409,7 +1417,7 @@ FP._use = function(schema, callback, reinit, insert) {
 		schema = F.TUtils.clone(schema);
 
 	if (typeof(callback) === 'boolean') {
-		var tmp = reinit;
+		let tmp = reinit;
 		reinit = callback;
 		callback = tmp;
 	}
@@ -1418,12 +1426,12 @@ FP._use = function(schema, callback, reinit, insert) {
 	// schema.COMPONENT_ID.config = {};
 	// schema.COMPONENT_ID.connections = { '0': [{ id: 'COMPONENT_ID', index: '2' }] }
 
-	var err = new F.ErrorBuilder();
+	const err = new F.ErrorBuilder();
 
 	if (schema) {
 
-		var keys = Object.keys(schema);
-		var ts = Date.now();
+		const keys = Object.keys(schema);
+		const ts = Date.now();
 
 		if (!insert) {
 			if (self.meta.flow.paused)
@@ -1445,9 +1453,9 @@ FP._use = function(schema, callback, reinit, insert) {
 				return;
 			}
 
-			var current = self.meta.flow[key];
-			var instance = schema[key];
-			var component = instance.component ? self.meta.components[instance.component] : null;
+			const current = self.meta.flow[key];
+			const instance = schema[key];
+			const component = instance.component ? self.meta.components[instance.component] : null;
 
 			// Component not found
 			if (!component) {
@@ -1469,11 +1477,11 @@ FP._use = function(schema, callback, reinit, insert) {
 				return;
 			}
 
-			var fi = self.meta.flow[key];
+			const fi = self.meta.flow[key];
 
 			if (!fi || reinit) {
 				self.meta.flow[key] = instance;
-				var tmp = self.initcomponent(key, component);
+				let tmp = self.initcomponent(key, component);
 				if (tmp) {
 					tmp.ts = ts;
 					tmp.newbie = true;
@@ -1486,6 +1494,13 @@ FP._use = function(schema, callback, reinit, insert) {
 				fi.size = instance.size;
 				fi.tab = instance.tab;
 				fi.ts = ts;
+
+				// From the view of the designer is the "repo" not visible
+				if (instance.repo)
+					fi.repo = instance.repo;
+				else if (!fi.repo)
+					fi.repo = {};
+
 				if (JSON.stringify(fi.config) !== JSON.stringify(instance.config)) {
 					F.TUtils.extend(fi.config, instance.config);
 					fi.configure && fi.configure(fi.config);
@@ -1499,9 +1514,9 @@ FP._use = function(schema, callback, reinit, insert) {
 		}, function() {
 
 			if (!insert) {
-				for (var key in self.meta.flow) {
+				for (let key in self.meta.flow) {
 					if (!BLACKLISTID[key]) {
-						var instance = self.meta.flow[key];
+						const instance = self.meta.flow[key];
 						if (instance.ts !== ts) {
 							instance.ready = false;
 							instance.isdestroyed = true;
@@ -1519,8 +1534,8 @@ FP._use = function(schema, callback, reinit, insert) {
 				}
 			}
 
-			for (var key in self.meta.flow) {
-				var instance = self.meta.flow[key];
+			for (let key in self.meta.flow) {
+				const instance = self.meta.flow[key];
 				if (instance.newbie) {
 					if (instance.init) {
 						try {
@@ -1541,7 +1556,6 @@ FP._use = function(schema, callback, reinit, insert) {
 			}
 
 			self.inc(-1);
-
 			self.cleanforce();
 			self.$events.schema && self.emit('schema', self.meta.flow);
 			callback && callback(err.length ? err : null);
@@ -1559,8 +1573,8 @@ FP._use = function(schema, callback, reinit, insert) {
 
 FP.initcomponent = function(key, component) {
 
-	var self = this;
-	var instance = self.meta.flow[key];
+	const self = this;
+	const instance = self.meta.flow[key];
 
 	if (instance.ready) {
 
@@ -1579,6 +1593,10 @@ FP.initcomponent = function(key, component) {
 	instance.isinstance = true;
 	instance.stats = { pending: 0, input: 0, output: 0, duration: 0, destroyed: 0 };
 	instance.cache = {};
+
+	if (!instance.repo)
+		instance.repo = {};
+
 	instance.id = key;
 	instance.module = component;
 	instance.ready = false;
@@ -1588,7 +1606,7 @@ FP.initcomponent = function(key, component) {
 		delete instance.options;
 	}
 
-	var tmp = component.config;
+	let tmp = component.config;
 	if (tmp)
 		instance.config = instance.config ? F.TUtils.extend(F.TUtils.clone(tmp), instance.config) : F.TUtils.clone(tmp);
 
@@ -1877,10 +1895,10 @@ FP.find = function(id) {
 };
 
 FP.send = function(path, body) {
-	var self = this;
+	const self = this;
 	if (!self.paused && self.meta && self.meta.flow) {
 		path = path.split(D);
-		var instance = self.meta.flow[path[0]];
+		const instance = self.meta.flow[path[0]];
 		if (instance)
 			instance.send(path[1], body);
 		return !!instance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "total5",
-  "version": "0.0.17-7",
+  "version": "0.0.17-9",
   "description": "Total.js framework v5",
   "main": "index.js",
   "directories": {

package/utils.js

@@ -1627,30 +1627,49 @@ exports.aistreamer = function(online, onmessage) {
 	};
 };
 
-exports.filestreamer = function(filename, onbuffer, onend, size) {
+exports.filestreamer = function(filename, onbuffer, onend, size = 1024 * 16, offset = 0) {
 
 	if (typeof(onend) === 'number') {
 		size = onend;
 		onend = null;
 	}
 
-	var Fd = null;
+	let Fd = null;
+	let Stat = null;
 
-	var read = function(offset) {
-		var buffer = Buffer.alloc(size || (1024 * 16));
+	const read = function(offset) {
+		const buffer = Buffer.alloc(size);
 		Total.Fs.read(Fd, buffer, 0, buffer.length, offset, function(err, bytes) {
 			if (err || !bytes) {
-				onend && onend(err);
 				Total.Fs.close(Fd, NOOP);
+				onend && onend(err);
 			} else {
-				onbuffer(buffer.length !== read ? buffer.slice(0, bytes) : buffer, next => read(offset + bytes));
+				const buff = buffer.length !== read ? buffer.slice(0, bytes) : buffer;
+				Stat.read += buff.length;
+				onbuffer(buff, function(stop) {
+					if (stop === true) {
+						Total.Fs.close(Fd, NOOP);
+						onend && onend();
+					} else
+						read(offset + bytes);
+				}, (Stat.read * 100) / Stat.size);
 			}
 		});
 	};
 
-	Total.Fs.open(filename, function(err, fd) {
-		Fd = fd;
-		read(0);
+	Total.Fs.lstat(filename, function(err, stat) {
+
+		if (err) {
+			onend && onend(err);
+			return;
+		}
+
+		Stat = stat;
+		Total.Fs.open(filename, function(err, fd) {
+			Fd = fd;
+			Stat.read = offset;
+			read(offset);
+		});
 	});
 
 };
@@ -6339,7 +6358,7 @@ function jsonschemaaitool(name) {
 	let required = t.required;
 	for (let key in t.properties) {
 		let prop = t.properties[key];
-		properties[key] = { type: prop.type, description: t.errors[key] };
+		properties[key] = { type: prop.type, description: t.errors ? (t.errors[key] || '') : '' };
 	}
 	return {
 		type: 'function',