@onetype/framework 2.0.41 → 2.0.43

package/addons/ai/addon.js

@@ -0,0 +1,78 @@
+import onetype from '#framework/load.js';
+
+const ai = onetype.Addon('ai', (ai) =>
+{
+	ai.providers = onetype.Addon('ai.providers', (addon) =>
+	{
+		addon.Field('id', ['string']);
+		addon.Field('name', ['string', '']);
+		addon.Field('endpoint', ['string']);
+		addon.Field('key', ['string', '']);
+		addon.Field('default', ['boolean', false]);
+		addon.Field('model', ['string', '']);
+		addon.Field('models', ['object', {}]);
+		addon.Field('onBeforeRequest', ['function']);
+		addon.Field('onAfterRequest', ['function']);
+		addon.Field('onParse', ['function']);
+	});
+
+	ai.agents = onetype.Addon('ai.agents', (addon) =>
+	{
+		addon.Field('id', ['string|number']);
+		addon.Field('name', ['string', '']);
+		addon.Field('description', ['string', '']);
+		addon.Field('instructions', ['string', '']);
+		addon.Field('commands', ['array', []]);
+		addon.Field('tokens', ['number', 8000]);
+		addon.Field('provider', ['string', '']);
+		addon.Field('model', ['string', '']);
+
+		addon.Field('condition', ['function']);
+
+		addon.Field('temperature', ['number', 0]);
+		addon.Field('top_p', ['number', 0.9]);
+		addon.Field('top_k', ['number', 20]);
+		addon.Field('presence_penalty', ['number', 0]);
+
+		addon.Field('format', ['string', 'json']);
+		addon.Field('input', ['object', {}]);
+		addon.Field('output', ['object|function', {}]);
+
+		addon.Field('onBefore', ['function']);
+		addon.Field('onAfter', ['function']);
+		addon.Field('onSuccess', ['function']);
+		addon.Field('onFail', ['function']);
+	});
+
+	ai.pipelines = onetype.Addon('ai.pipelines', (addon) =>
+	{
+		addon.Field('id', ['string']);
+		addon.Field('name', ['string', '']);
+		addon.Field('description', ['string', '']);
+		addon.Field('usage', ['number', 0]);
+		addon.Field('steps', ['array', []]);
+	});
+
+	ai.orchestrators = onetype.Addon('ai.orchestrators', (addon) =>
+	{
+		addon.Field('id', ['string|number']);
+		addon.Field('parent', ['string']);
+		addon.Field('prompt', ['string']);
+		addon.Field('agents', ['array', []]);
+		addon.Field('data', ['object', {}]);
+		addon.Field('status', ['string', 'idle']);
+		addon.Field('state', ['object', null]);
+		addon.Field('history', ['array', []]);
+		addon.Field('steps', ['number', 10]);
+
+		addon.Field('provider', ['string', '']);
+
+		addon.Field('onTasks', ['function', null]);
+		addon.Field('onStep', ['function', null]);
+		addon.Field('onSummary', ['function', null]);
+		addon.Field('onSuccess', ['function', null]);
+		addon.Field('onFail', ['function', null]);
+	});
+});
+
+export default ai;

package/addons/ai/addons/agents/item/functions/describe.js

@@ -0,0 +1,28 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Fn('item.describe', function(item, fields, indent = 0)
+{
+	const lines = [];
+
+	for (const [key, field] of Object.entries(fields))
+	{
+		if (field.populate === false) 
+		{
+			continue
+		};
+
+		const prefix = '  '.repeat(indent) + '- ';
+		const description = '[' + field.type + ']: ' + field.description;
+
+		lines.push(prefix + '' + key + '' + description);
+
+		const nested = field.each?.config || field.config;
+
+		if (nested)
+		{
+			lines.push(item.Fn('describe', nested, indent + 1));
+		}
+	}
+
+	return lines.join('\n');
+});

package/addons/ai/addons/agents/item/functions/execute.js

@@ -0,0 +1,41 @@
+import ai from '#ai/addon.js';
+
+
+ai.agents.Fn('item.execute', async function(item, payload, stream = null)
+{
+	const provider = item.Get('provider') ? ai.providers.ItemGet(item.Get('provider')) : ai.providers.Fn('default');
+
+	if (!provider)
+	{
+		throw new Error('Provider not found: ' + (item.Get('provider') || 'default'));
+	}
+
+	const result = await provider.Fn('request', payload, stream);
+
+	const meta = { 
+		time: result.time,
+		tokens: result.tokens,
+		tps: result.tps,
+		reasoning: result.reasoning
+	};
+
+	if (item.Get('format') === 'text')
+	{
+		return { content: result.content, _meta: meta };
+	}
+
+	let parsed;
+
+	try
+	{
+		parsed = JSON.parse(result.content);
+	}
+	catch (error)
+	{
+		throw new Error('Failed to parse agent response as JSON: ' + result.content.slice(0, 200));
+	}
+
+	parsed._meta = meta;
+
+	return parsed;
+});

package/addons/ai/addons/agents/item/functions/messages.js

@@ -0,0 +1,38 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Fn('item.messages', function(item, data = {}, history = null)
+{
+	const state = onetype.StateGet();
+
+	const instructions = item.Get('instructions');
+	const input = item.Get('input');
+	const output = typeof item.Get('output') === 'function' ? item.Get('output')({input}) : item.Get('output');
+	const messages = [];
+
+	const system = [
+		instructions,
+		state && Object.keys(state).length ? 'State:\n' + JSON.stringify(state, null, 2) : null,
+		input && Object.keys(input).length ? 'Input fields:\n' + item.Fn('describe', input) : null,
+		output && Object.keys(output).length && item.Get('format') === 'json' ? 'Output fields:\n' + item.Fn('describe', output) : null,
+	].filter(Boolean).join('\n\n');
+
+	if(system)
+	{
+		messages.push({role: 'system', content: system});
+	}
+
+	if(Array.isArray(history) && history.length)
+	{
+		for(const entry of history)
+		{
+			messages.push({role: entry.role, content: entry.content});
+		}
+	}
+
+	if(data && Object.keys(data).length)
+	{
+		messages.push({role: 'user', content: JSON.stringify(data, null, 2)});
+	}
+
+	return messages;
+});

package/addons/ai/addons/agents/item/functions/run.js

@@ -0,0 +1,49 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Fn('item.run', async function(item, input = {}, history = null, stream = null)
+{
+	input = item.Get('input') ? onetype.DataDefine(input, item.Get('input')) : {};
+
+	if (!item.Get('instructions'))
+	{
+		let output = {};
+
+		item.Get('onAfter') && await item.Get('onAfter')({ input, output, payload: {} });
+
+		output._meta = { time: 0, tokens: { input: 0, output: 0 }, tps: 0 };
+
+		return output;
+	}
+
+	const schema = typeof item.Get('output') === 'function' ? item.Get('output')({ input }) : item.Get('output');
+
+	const payload = {
+		model: item.Get('model'),
+		tokens: item.Get('tokens'),
+		messages: item.Fn('messages', input, history),
+		temperature: item.Get('temperature'),
+		top_p: item.Get('top_p'),
+		top_k: item.Get('top_k'),
+		presence_penalty: item.Get('presence_penalty')
+	};
+
+	if (item.Get('format') === 'json')
+	{
+		payload.json_schema = item.Fn('schema', schema);
+	}
+
+	item.Get('onBefore') && item.Get('onBefore')({ input, payload });
+
+	let { _meta, ...output } = await item.Fn('execute', payload, stream);
+
+	if (item.Get('format') === 'json' && schema)
+	{
+		output = onetype.DataDefine(output, schema);
+	}
+
+	item.Get('onAfter') && await item.Get('onAfter')({ input, payload, output });
+
+	output._meta = _meta;
+
+	return output;
+});

package/addons/ai/addons/agents/item/functions/schema.js

@@ -0,0 +1,45 @@
+import ai from '#ai/addon.js';
+
+ai.agents.Fn('item.schema', function(item, fields)
+{
+	const schema = { type: 'object', properties: {}, required: [], additionalProperties: false };
+
+	if (!fields || typeof fields !== 'object')
+	{
+		return schema;
+	}
+
+	for (const [key, field] of Object.entries(fields))
+	{
+		if (field.populate === false)
+		{
+			continue;
+		}
+
+		const type = field.type || 'string';
+		const prop = { type };
+
+		if (type === 'array')
+		{
+			prop.items = field.each?.config ? item.Fn('schema', field.each.config) : (field.each || { type: 'string' });
+		}
+
+		if (type === 'string' && field.options)
+		{
+			prop.enum = field.options;
+		}
+
+		if (field.required === false)
+		{
+			prop.type = [prop.type, 'null'];
+		}
+		else
+		{
+			schema.required.push(key);
+		}
+
+		schema.properties[key] = prop;
+	}
+
+	return schema;
+});

package/addons/ai/addons/agents/load.js

@@ -0,0 +1,9 @@
+import ai from '#ai/addon.js';
+
+import '#ai/addons/agents/item/functions/schema.js';
+import '#ai/addons/agents/item/functions/describe.js';
+import '#ai/addons/agents/item/functions/messages.js';
+import '#ai/addons/agents/item/functions/execute.js';
+import '#ai/addons/agents/item/functions/run.js';
+
+export default ai.agents;

package/addons/ai/addons/orchestrators/item/functions/agents/execute.js

@@ -0,0 +1,14 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.agents.execute', async function(item, state, id, input)
+{
+	const agent = ai.agents.ItemGet(id);
+
+	const result = await agent.Fn('run', input, item.Get('history'));
+	const { _meta, ...rest } = result;
+
+	state.tokens.input += result._meta.tokens.input;
+	state.tokens.output += result._meta.tokens.output;
+
+	return rest;
+});

package/addons/ai/addons/orchestrators/item/functions/agents/steps.js

@@ -0,0 +1,23 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.agents.steps', async function(item, state, prompt, data)
+{
+	const payload = {
+		prompt: prompt,
+		agents: state.agents,
+		data: data,
+		pipelines: []
+	};
+
+	const result = await ai.agents.ItemGet('orchestrator-steps').Fn('run', payload, item.Get('history'));
+
+	state.tokens.input += result._meta.tokens.input;
+	state.tokens.output += result._meta.tokens.output;
+
+	return { 
+		reasoning: result.reasoning, 
+		achievable: result.achievable, 
+		steps: result.steps, 
+		conclusion: result.conclusion 
+	};
+});

package/addons/ai/addons/orchestrators/item/functions/modes/action.js

@@ -0,0 +1,131 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.modes.action', async function(item, state)
+{
+	this.methods.resolve = (value) =>
+	{
+		if(typeof value !== 'string' || !value.startsWith('$'))
+		{
+			return value;
+		}
+
+		return onetype.Function(value.slice(1), state.data);
+	};
+
+	this.methods.input = (input) =>
+	{
+		const resolved = {};
+
+		for(const [key, value] of Object.entries(input || {}))
+		{
+			resolved[key] = this.methods.resolve(value);
+		}
+
+		return resolved;
+	};
+
+	this.methods.check = (step) =>
+	{
+		if(!step.if)
+		{
+			return true;
+		}
+
+		return !!this.methods.resolve(step.if);
+	};
+
+	this.methods.agent = async (step) =>
+	{
+		if(!this.methods.check(step))
+		{
+			console.log(step);
+
+			item.Fn('history', 'assistant', 'Condition not met, skipped: ' + step.agent);
+			return;
+		}
+
+		const result = await item.Fn('agents.execute', state, step.agent, this.methods.input(step.input));
+
+		if(step.as)
+		{
+			state.data[step.as] = result;
+		}
+
+		item.Fn('history', 'assistant', 'Ran "' + step.agent + '" and got output keys: ' + Object.keys(result) + (step.as ? '. Stored all as $' + step.as : ''));
+	};
+
+	this.methods.loop = async (step) =>
+	{
+		// if(!this.methods.check(step))
+		// {
+		// 	return item.Fn('history', 'assistant', 'Condition not met, skipped loop: ' + step.goal);
+		// }
+
+		const items = this.methods.resolve(step.loop);
+
+		if(!Array.isArray(items) || !items.length)
+		{
+			return item.Fn('history', 'assistant', 'Loop skipped, empty or not array: ' + step.loop);
+		}
+
+		item.Fn('history', 'assistant', 'Looping ' + items.length + ' items.');
+
+		/* Plan once with first item */
+
+		const fields = Object.keys(items[0] || {}).join(', ');
+		const prompt = step.goal + '. $item is available with fields: ' + fields + '. Use $item directly.';
+
+		for(let i = 0; i < items.length; i++)
+		{
+			const child = ai.orchestrators.Item({
+				parent: item.Get('id'),
+				prompt,
+				data: { item: items[i] },
+				steps: 10,
+			});
+
+			await child.Fn('run');
+
+			state.tokens.input += child.Get('state')?.tokens?.input || 0;
+			state.tokens.output += child.Get('state')?.tokens?.output || 0;
+
+			child.Remove();
+		}
+	};
+
+	this.methods.execute = async (steps) =>
+	{
+		for(const step of steps)
+		{
+			if(step.loop)
+			{
+				item.Fn('history', 'user', step.goal);
+				await this.methods.loop(step);
+			}
+			else if(step.agent)
+			{
+				item.Fn('history', 'user', step.goal);
+				await this.methods.agent(step);
+			}
+		}
+	};
+
+	/* Plan */
+
+	const { steps, reasoning, conclusion, achievable } = await item.Fn('agents.steps', state, state.prompt, state.data);
+
+	console.log(item.Get('id'), reasoning, steps);
+	if(!achievable)
+	{
+		item.Fn('history', 'assistant', 'Not achievable: ' + reasoning);
+		item.Fn('emit', 'onFail', { reasoning, conclusion });
+		return;
+	}
+
+	item.Fn('history', 'assistant', reasoning);
+	item.Fn('emit', 'onStep', { status: 'planned', conclusion, steps });
+
+	/* Execute */
+
+	await this.methods.execute(steps);
+});

package/addons/ai/addons/orchestrators/item/functions/run.js

@@ -0,0 +1,28 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.run', async function(item)
+{
+	const state = item.Fn('state');
+
+	item.Set('status', 'running');
+	item.Set('state', state);
+
+	try
+	{
+		await item.Fn('modes.action', state);
+
+		item.Set('status', 'completed');
+		item.Fn('emit', 'onSuccess', { state });
+	}
+	catch (error)
+	{
+		item.Set('status', 'failed');
+		item.Fn('emit', 'onFail', { error, state });
+
+		throw error;
+	}
+	finally
+	{
+		return state;
+	}
+});

package/addons/ai/addons/orchestrators/item/functions/utils/emit.js

@@ -0,0 +1,11 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.emit', function(item, name, data)
+{
+	const callback = item.Get(name);
+
+	if (callback && typeof callback === 'function')
+	{
+		callback(data);
+	}
+});

package/addons/ai/addons/orchestrators/item/functions/utils/history.js

@@ -0,0 +1,8 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.history', function(item, role, content)
+{
+	const history = item.Get('history');
+	history.push({ role, content });
+	item.Set('history', history);
+});

package/addons/ai/addons/orchestrators/item/functions/utils/state.js

@@ -0,0 +1,29 @@
+import ai from '#ai/addon.js';
+
+ai.orchestrators.Fn('item.state', function(item, overrides = {})
+{
+	const agents = Object.values(ai.agents.Items()).map((agent) =>
+	{
+		if(agent.Get('condition') && !agent.Get('condition')())
+		{
+			return false;
+		}
+
+		return {
+			id: agent.Get('id'),
+			description: agent.Get('description'),
+			input: agent.Get('input'),
+			output: agent.Get('output')
+		};
+	});
+
+	const state = {
+		step: 0,
+		prompt: item.Get('prompt'),
+		tokens: { input: 0, output: 0 },
+		agents: agents.filter(Boolean),
+		data: item.Get('data')
+	};
+
+	return Object.assign(state, overrides);
+});

package/addons/ai/addons/orchestrators/load.js

@@ -0,0 +1,15 @@
+import ai from '#ai/addon.js';
+
+
+/* Functions */
+import '#ai/addons/orchestrators/item/functions/utils/emit.js';
+import '#ai/addons/orchestrators/item/functions/utils/history.js';
+import '#ai/addons/orchestrators/item/functions/utils/state.js';
+
+import '#ai/addons/orchestrators/item/functions/agents/steps.js';
+import '#ai/addons/orchestrators/item/functions/agents/execute.js';
+
+import '#ai/addons/orchestrators/item/functions/modes/action.js';
+import '#ai/addons/orchestrators/item/functions/run.js';
+
+export default ai.orchestrators;

package/addons/ai/addons/pipelines/functions/execute.js

@@ -0,0 +1,56 @@
+import ai from '#ai/addon.js';
+
+ai.pipelines.Fn('execute', async function(step, context)
+{
+	if(step.condition && !step.condition(context))
+	{
+		return null;
+	}
+
+	const input = {};
+
+	if(step.input)
+	{
+		Object.assign(input, step.input);
+	}
+
+	if(step.map)
+	{
+		for(const [key, path] of Object.entries(step.map))
+		{
+			const parts = path.split('.');
+			let value = context.results;
+
+			for(const part of parts)
+			{
+				value = value?.[part];
+			}
+
+			input[key] = value;
+		}
+	}
+
+	if(step.type === 'command')
+	{
+		return await $ot.command(step.command, input);
+	}
+
+	if(step.type === 'ai')
+	{
+		const agent = ai.agents.ItemGet(step.agent);
+
+		if(!agent)
+		{
+			throw onetype.Error(404, 'Agent :id: not found.', { id: step.agent });
+		}
+
+		return await agent.Fn('run', input, context.history);
+	}
+
+	if(step.type === 'pipeline')
+	{
+		return await ai.pipelines.Fn('run', step.pipeline, input, context);
+	}
+
+	throw onetype.Error(400, 'Unknown step type :type:.', { type: step.type });
+});

package/addons/ai/addons/pipelines/functions/run.js

@@ -0,0 +1,72 @@
+import ai from '#ai/addon.js';
+
+ai.pipelines.Fn('run', async function(id, input = {}, parent = null)
+{
+	const pipeline = ai.pipelines.ItemGet(id);
+
+	if(!pipeline)
+	{
+		throw onetype.Error(404, 'Pipeline :id: not found.', { id });
+	}
+
+	const context = parent || {
+		input,
+		results: {},
+		history: []
+	};
+
+	if(!parent)
+	{
+		context.results._input = input;
+	}
+
+	const steps = pipeline.Get('steps');
+
+	for(const step of steps)
+	{
+		if(step.loop)
+		{
+			const parts = step.loop.split('.');
+			let items = context.results;
+
+			for(const part of parts)
+			{
+				items = items?.[part];
+			}
+
+			if(!Array.isArray(items))
+			{
+				continue;
+			}
+
+			const results = [];
+
+			for(const item of items)
+			{
+				const scoped = {
+					input: item,
+					results: { ...context.results, _current: item },
+					history: context.history
+				};
+
+				const result = await ai.pipelines.Fn('execute', step, scoped);
+				results.push(result);
+			}
+
+			context.results[step.id] = results;
+		}
+		else
+		{
+			const result = await ai.pipelines.Fn('execute', step, context);
+
+			if(result !== null)
+			{
+				context.results[step.id] = result;
+			}
+		}
+	}
+
+	pipeline.Set('usage', pipeline.Get('usage') + 1);
+
+	return context.results;
+});