@onetype/framework 2.0.42 → 2.0.44

package/addons/ai/addons/pipelines/load.js

@@ -0,0 +1,6 @@
+import ai from '#ai/addon.js';
+
+import '#ai/addons/pipelines/functions/execute.js';
+import '#ai/addons/pipelines/functions/run.js';
+
+export default ai.pipelines;

package/addons/ai/addons/providers/functions/default.js

@@ -0,0 +1,8 @@
+import ai from '#ai/addon.js';
+
+ai.providers.Fn('default', function()
+{
+	const items = Object.values(ai.providers.Items());
+
+	return items.find(p => p.Get('default')) || items[0] || null;
+});

package/addons/ai/addons/providers/item/functions/request.js

@@ -0,0 +1,108 @@
+import ai from '#ai/addon.js';
+
+ai.providers.Fn('item.request', async function(provider, payload, stream = null)
+{
+	const key = (typeof process !== 'undefined' && process.env ? process.env[provider.Get('key')] : '') || '';
+	const model = payload.model || provider.Get('model');
+	const config = provider.Get('models')[model] || {};
+	const before = provider.Get('onBeforeRequest')({ payload: { ...payload, model }, key, config });
+
+	if (stream)
+	{
+		before.body.stream = true;
+	}
+
+	const endpoint = provider.Get('endpoint') + (stream ? (provider.Get('endpoint').includes('?') ? '&' : '?') + 'streaming=true' : '');
+	const start = Date.now();
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), 120000);
+
+	const response = await fetch(endpoint,
+	{
+		method: 'POST',
+		headers: before.headers,
+		body: JSON.stringify(before.body),
+		signal: controller.signal
+	});
+
+	clearTimeout(timer);
+
+	if (!response.ok)
+	{
+		throw new Error('API error: ' + response.status);
+	}
+
+	if (stream)
+	{
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		const parse = provider.Get('onParse');
+		let content = '';
+		let buffer = '';
+		let tokens = 0;
+
+		while (true)
+		{
+			const { done, value } = await reader.read();
+
+			if (done)
+			{
+				break;
+			}
+
+			buffer += decoder.decode(value, { stream: true });
+
+			const lines = buffer.split('\n');
+			buffer = lines.pop();
+
+			for (const line of lines)
+			{
+				const token = parse(line);
+
+				if (token)
+				{
+					content += token;
+					tokens++;
+					stream(token);
+				}
+			}
+		}
+
+		if (buffer.trim())
+		{
+			const token = parse(buffer);
+
+			if (token)
+			{
+				content += token;
+				tokens++;
+				stream(token);
+			}
+		}
+
+		const time = Date.now() - start;
+		const input = Math.ceil(JSON.stringify(before.body).length / 4);
+		const tps = time > 0 ? parseFloat((tokens / (time / 1000)).toFixed(2)) : 0;
+
+		return {
+			content,
+			reasoning: null,
+			tokens: { input, output: tokens },
+			time,
+			tps
+		};
+	}
+
+	const raw = await response.json();
+	const time = Date.now() - start;
+	const after = provider.Get('onAfterRequest')({ response: raw, model, config });
+	const tps = time > 0 ? parseFloat((after.tokens.output / (time / 1000)).toFixed(2)) : 0;
+
+	return {
+		content: after.content,
+		reasoning: after.reasoning,
+		tokens: after.tokens,
+		time,
+		tps
+	};
+});

package/addons/ai/addons/providers/items/nue.js

@@ -0,0 +1,69 @@
+import ai from '#ai/addon.js';
+
+ai.providers.Item({
+	id: 'nue',
+	name: 'Nue Tools',
+	default: false,
+	endpoint: 'https://nue.tools.divhunt.com/api/run/ai-chat',
+	key: 'NUE_API_KEY',
+	model: 'qwen3.5-9b',
+	models: {
+		'qwen3.5-9b': {
+			tokens: 8000
+		}
+	},
+	onBeforeRequest: ({ payload, key }) =>
+	{
+		const body = {
+			messages: payload.messages,
+			tokens: payload.tokens || 2000,
+			temperature: payload.temperature ?? 0.15,
+			top_p: payload.top_p ?? 0.8,
+			top_k: payload.top_k ?? 20,
+			presence_penalty: payload.presence_penalty ?? 1.5,
+			thinking: payload.thinking || false,
+			stream: false,
+			json_schema: payload.json_schema
+		};
+
+		return {
+			headers: {
+				'Content-Type': 'application/json',
+				...(key && { 'Authorization': 'Bearer ' + key })
+			},
+			body
+		};
+	},
+	onAfterRequest: ({ response }) =>
+	{
+		const data = response.data || {};
+		const usage = data.usage || {};
+
+		return {
+			content: (data.response || '').trim(),
+			reasoning: (data.thinking || '').trim() || null,
+			tokens: {
+				input: usage.prompt_tokens || 0,
+				output: usage.completion_tokens || 0
+			}
+		};
+	},
+	onParse: (line) =>
+	{
+		const trimmed = line.trim();
+
+		if (!trimmed)
+		{
+			return null;
+		}
+
+		try
+		{
+			return JSON.parse(trimmed).response || null;
+		}
+		catch (e)
+		{
+			return null;
+		}
+	}
+});

package/addons/ai/addons/providers/items/ollama.js

@@ -0,0 +1,79 @@
+import ai from '#ai/addon.js';
+
+ai.providers.Item({
+	id: 'ollama',
+	name: 'Ollama',
+	default: true,
+	endpoint: 'http://localhost:11434/api/chat',
+	model: 'devstral-small-2:24b-cloud',
+	models: {
+		'devstral-small-2:24b-cloud': {
+			tokens: 32000
+		}
+	},
+	onBeforeRequest: ({ payload, key }) =>
+	{
+		const messages = payload.messages.map(m => ({
+			role: m.role,
+			content: m.content
+		}));
+
+		if(payload.json_schema)
+		{
+			messages[messages.length - 1].content += '\n\nRespond with valid JSON matching this schema:\n' + JSON.stringify(payload.json_schema);
+		}
+
+		return {
+			headers: {
+				'Content-Type': 'application/json'
+			},
+			body: {
+				model: payload.model || 'devstral-small-2:24b-cloud',
+				messages,
+				stream: false,
+				options: {
+					temperature: payload.temperature ?? 0.15,
+					top_p: payload.top_p ?? 0.9,
+					top_k: payload.top_k ?? 20,
+					num_predict: payload.tokens || 2000
+				},
+				format: payload.json_schema ? 'json' : undefined
+			}
+		};
+	},
+	onAfterRequest: ({ response }) =>
+	{
+		const message = response.message || {};
+		let content = (message.content || '').trim();
+
+		if(content.includes('```json'))
+		{
+			content = content.split('```json')[1].split('```')[0].trim();
+		}
+		else if(content.includes('```'))
+		{
+			content = content.split('```')[1].split('```')[0].trim();
+		}
+
+		return {
+			content,
+			reasoning: null,
+			tokens: {
+				input: response.prompt_eval_count || 0,
+				output: response.eval_count || 0
+			}
+		};
+	},
+	onParse: (line) =>
+	{
+		try
+		{
+			const data = JSON.parse(line);
+			return data.message?.content || null;
+		}
+		catch(e)
+		{
+			return null;
+		}
+	}
+});

package/addons/ai/addons/providers/load.js

@@ -0,0 +1,8 @@
+import ai from '#ai/addon.js';
+
+import '#ai/addons/providers/items/nue.js';
+import '#ai/addons/providers/items/ollama.js';
+import '#ai/addons/providers/functions/default.js';
+import '#ai/addons/providers/item/functions/request.js';
+
+export default ai.providers;

package/addons/ai/items/agents/steps.js

@@ -0,0 +1,159 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Item({
+	id: 'orchestrator-steps',
+	name: 'Orchestrator Steps',
+	description: 'Plans linear execution steps for a goal.',
+	instructions: `
+You create execution steps from a goal and available agents.
+
+STEPS:
+- Agent: {"goal": "...", "agent": "id", "input": {...}, "as": "name"}
+- Loop: {"goal": "task for one item", "loop": "$expression"}
+- Any step can have "if": "$expression" to guard execution.
+
+$ REFERENCES:
+- $ prefix = JS expression. No $ = literal.
+- Scope: all "as" results + "data" variables directly (not $data.x, just $x).
+
+RULES:
+1. Use only provided agent IDs.
+2. Use only values from goal or $ references.
+3. "as" stores the ENTIRE agent output object. To access a field, use $name.field. A loop over an array field inside the output must be $name.arrayField, never just $name.
+4. Loop iterates arrays. Loop goal is for ONE item.
+5. Use data variables when available.
+6. Fewest steps.
+7. No matching agent = achievable false.
+
+FORMAT EXAMPLES:
+- Agent: {"goal": "...", "agent": "x", "input": {"field": "literal"}, "as": "result"}
+- Agent with ref: {"goal": "...", "agent": "y", "input": {"field": "$result.value"}, "as": "output"}
+- Loop: {"goal": "process this item", "loop": "$result.items"}
+- Agent in loop uses $item: {"goal": "...", "agent": "z", "input": {"field": "$item.name"}}
+- Guarded agent: {"goal": "...", "agent": "z", "input": {...}, "if": "$output.flag"}
+- JS in $ref: {"input": {"count": "$item.name.length", "upper": "$item.name.toUpperCase()"}}
+
+REASONING:
+- For each agent, state what it returns from the output schema.
+- For each loop, trace: $name → output schema → array field → $name.field.
+- For each $item reference, confirm it matches a field from the loop source array items.
+	`,
+	condition: () => false,
+	tokens: 3000,
+	input: {
+		prompt: {
+			type: 'string',
+			description: 'The goal to plan execution for'
+		},
+		data: {
+			type: 'object',
+			description: 'Variables available in current scope. Reference with $ prefix.'
+		},
+		agents: {
+			type: 'array',
+			description: 'Available agents',
+			each: {
+				type: 'object',
+				config: {
+					id: {
+						type: 'string',
+						description: 'Agent ID'
+					},
+					description: {
+						type: 'string',
+						description: 'What this agent does'
+					},
+					input: {
+						type: 'object',
+						description: 'Input fields this agent accepts'
+					},
+					output: {
+						type: 'object',
+						description: 'Output fields this agent returns'
+					}
+				}
+			}
+		},
+		pipelines: {
+			type: 'array',
+			description: 'Predefined step sequences. Use as-is or adapt to the goal. Higher usage = more proven.',
+			each: {
+				type: 'object',
+				config: {
+					id: {
+						type: 'string',
+						description: 'Pipeline ID'
+					},
+					name: {
+						type: 'string',
+						description: 'Pipeline name'
+					},
+					description: {
+						type: 'string',
+						description: 'What this pipeline does'
+					},
+					usage: {
+						type: 'number',
+						description: 'How many times this pipeline was used'
+					},
+					steps: {
+						type: 'array',
+						description: 'The predefined steps'
+					}
+				}
+			}
+		}
+	},
+	output: {
+		reasoning: {
+			type: 'string',
+			description: 'Explain why this plan was chosen, what each step does, and how data flows between steps. If not achievable, explain what is missing. Always check input and output schema.'
+		},
+		achievable: {
+			type: 'boolean',
+			description: 'Whether the goal can be fully achieved with the available agents. If false, steps must be empty.'
+		},
+		steps: {
+			type: 'array',
+			description: 'Flat list of steps to execute',
+			each: {
+				type: 'object',
+				config: {
+					goal: {
+						type: 'string',
+						description: 'What this step does (max 20 words).'
+					},
+					agent: {
+						type: 'string',
+						required: false,
+						description: 'Agent ID to call. Omit for loop steps.'
+					},
+					input: {
+						type: 'object',
+						required: false,
+						description: 'Input for agent. Values can be literals or $ expressions.'
+					},
+					as: {
+						type: 'string',
+						required: false,
+						description: 'Variable name to store result'
+					},
+					loop: {
+						type: 'string',
+						required: false,
+						description: '$ expression that resolves to an array. Omit for agent steps.'
+					},
+					if: {
+						type: 'string',
+						required: false,
+						description: '$ expression condition. Step executes only when truthy.'
+					}
+				}
+			}
+		},
+		conclusion: {
+			type: 'string',
+			description: 'Short first-person message to the user (max 15 words). Speak as their assistant.'
+		}
+	}
+});

package/addons/ai/items/agents/summary.js

@@ -0,0 +1,29 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Item({
+	id: 'orchestrator-summary',
+	name: 'Orchestrator Summary',
+	description: 'Summarizes what happened during execution based on history.',
+	instructions: `
+You receive a conversation history of an AI assistant executing tasks.
+Write a short, friendly first-person summary of what was done.
+Include key results, numbers, and outcomes.
+If something failed or was skipped, mention it briefly.
+Keep it under 3 sentences.
+	`,
+	condition: () => false,
+	tokens: 500,
+	format: 'json',
+	input: {
+		history: {
+			type: 'array',
+			description: 'Conversation history of the execution'
+		}
+	},
+	output: {
+		summary: {
+			type: 'string',
+			description: 'Short first-person summary of what happened'
+		}
+	}
+});

package/addons/ai/items/orchestrators/general.js

@@ -0,0 +1,7 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Item({
+	id: 'general',
+	steps: 20,
+	concurrency: 3
+});

package/addons/ai/load.js

@@ -0,0 +1,13 @@
+import ai from '#ai/addon.js';
+
+import '#ai/addons/providers/load.js';
+import '#ai/addons/agents/load.js';
+import '#ai/addons/pipelines/load.js';
+import '#ai/addons/orchestrators/load.js';
+
+/* Items */
+import '#ai/items/agents/steps.js';
+import '#ai/items/agents/summary.js';
+import '#ai/items/orchestrators/general.js';
+
+export default ai;

package/addons/ai/test/agents.js

@@ -0,0 +1,149 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Item({
+	id: 'read-emails',
+	name: 'Read Emails',
+	description: 'Reads emails by category and returns a list of emails.',
+	format: 'json',
+	input: {
+		category: {
+			type: 'string',
+			required: true,
+			description: 'Email category to filter by (business, personal, support)',
+			options: ['business', 'personal', 'support']
+		}
+	},
+	output: {
+		emails: {
+			type: 'array',
+			description: 'List of emails',
+			each: {
+				type: 'object',
+				config: {
+					id: { type: 'string', description: 'Email ID' },
+					sender: { type: 'string', description: 'Sender email' },
+					subject: { type: 'string', description: 'Subject line' },
+					body: { type: 'string', description: 'Email body' }
+				}
+			}
+		}
+	},
+	onAfter: async ({ input, output }) =>
+	{
+		const database = {
+			business: [
+				{
+					id: 'email-001',
+					sender: 'john@acme.com',
+					subject: 'Server down - urgent',
+					body: 'Hey team, the production server went down at 3:42 AM. Error logs show a memory leak in the payment service. Need someone to look at this ASAP. Customers are getting 502 errors on checkout.'
+				},
+				{
+					id: 'email-002',
+					sender: 'sarah@client.io',
+					subject: 'New project proposal',
+					body: 'Hi, we would like to discuss a new project for our e-commerce platform. Budget is $50k, timeline is 3 months. Can we schedule a call this week?'
+				},
+				{
+					id: 'email-003',
+					sender: 'mike@partner.dev',
+					subject: 'API integration ready',
+					body: 'The payment gateway API integration is complete and tested. All endpoints are live in staging. Ready for your team to review and approve for production deployment.'
+				}
+			],
+			personal: [
+				{
+					id: 'email-004',
+					sender: 'mom@gmail.com',
+					subject: 'Dinner on Sunday?',
+					body: 'Hey, are you free for dinner this Sunday? Dad is making his famous lasagna.'
+				}
+			]
+		};
+
+		output.emails = database[input.category] || [];
+	}
+});
+
+ai.agents.Item({
+	id: 'summarize',
+	name: 'Summarize',
+	description: 'Summarizes text into a short, actionable message.',
+	format: 'json',
+	instructions: 'You receive an email with sender, subject, and body. Write a short 1-2 sentence summary that captures the key point and urgency level. Be direct.',
+	tokens: 500,
+	input: {
+		sender: { type: 'string', description: 'Email sender' },
+		subject: { type: 'string', description: 'Email subject' },
+		body: { type: 'string', description: 'Email body text' }
+	},
+	output: {
+		summary: { type: 'string', description: 'Short summary of the email' },
+		urgent: { type: 'boolean', description: 'Whether the email is urgent' }
+	}
+});
+
+ai.agents.Item({
+	id: 'send-slack',
+	name: 'Send Slack',
+	description: 'Sends a message to a Slack channel via webhook.',
+	format: 'json',
+	input: {
+		text: {
+			type: 'string',
+			required: true,
+			description: 'Message text to send'
+		}
+	},
+	output: {
+		sent: { type: 'boolean', description: 'Whether the message was sent' }
+	},
+	onAfter: async ({ input, output }) =>
+	{
+		const response = await fetch(process.env.SLACK_WEBHOOK, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ text: input.text })
+		});
+
+		output.sent = response.ok;
+	}
+});
+
+ai.agents.Item({
+	id: 'create-task',
+	name: 'Create Task',
+	description: 'Creates a task in the project management system.',
+	format: 'json',
+	input: {
+		title: {
+			type: 'string',
+			required: true,
+			description: 'Task title'
+		},
+		description: {
+			type: 'string',
+			description: 'Task description'
+		},
+		priority: {
+			type: 'string',
+			value: 'medium',
+			description: 'Task priority level',
+			options: ['low', 'medium', 'high', 'urgent']
+		},
+		assignee: {
+			type: 'string',
+			description: 'Person to assign the task to'
+		}
+	},
+	output: {
+		id: { type: 'string', description: 'Created task ID' },
+		created: { type: 'boolean', description: 'Whether the task was created' }
+	},
+	onAfter: async ({ input, output }) =>
+	{
+		console.log('[TASK CREATED]', input.title, '| priority:', input.priority, '| assignee:', input.assignee || 'unassigned');
+		output.id = 'task-' + Date.now();
+		output.created = true;
+	}
+});