@onetype/framework 2.0.40 → 2.0.42

package/addons/ai/agents/addon.js

@@ -0,0 +1,23 @@
+import onetype from 'onetype';
+
+const agents = onetype.Addon('agents', (addon) =>
+{
+    addon.Field('id', ['string|number']);
+    addon.Field('name', ['string', 'JSON']);
+    addon.Field('description', ['string', '']);
+    addon.Field('instructions', ['string', '']);
+    addon.Field('context', ['object|function', {}]);
+    addon.Field('commands', ['array', []]);
+    addon.Field('tokens', ['number', 8000]);
+    addon.Field('provider', ['string', '']);
+    addon.Field('model', ['string', '']);
+    addon.Field('input', ['object', {}]);
+    addon.Field('output', ['object', {}]);
+    addon.Field('stop', ['function']);
+    addon.Field('callback', ['function']);
+    addon.Field('onRun', ['function']);
+    addon.Field('onSuccess', ['function']);
+    addon.Field('onFail', ['function']);
+});
+
+export default agents;

package/addons/ai/agents/functions/parse.js

@@ -0,0 +1,129 @@
+import agents from '#agents/addon.js';
+
+agents.Fn('parse', function(content)
+{
+    let text = (content || '').trim();
+
+    text = text.replace(/^```(?:json)?\n?/i, '').replace(/\n?```$/i, '');
+
+    /* Find first balanced JSON object */
+    const start = text.indexOf('{');
+
+    if (start === -1)
+    {
+        console.log('[PARSE ERROR] No JSON found in response:', text);
+        throw new Error('Invalid JSON response');
+    }
+
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let end = -1;
+
+    for (let i = start; i < text.length; i++)
+    {
+        const char = text[i];
+
+        if (escape)
+        {
+            escape = false;
+            continue;
+        }
+
+        if (char === '\\' && inString)
+        {
+            escape = true;
+            continue;
+        }
+
+        if (char === '"')
+        {
+            inString = !inString;
+            continue;
+        }
+
+        if (!inString)
+        {
+            if (char === '{') depth++;
+            if (char === '}') depth--;
+
+            if (depth === 0)
+            {
+                end = i;
+                break;
+            }
+        }
+    }
+
+    if (end === -1)
+    {
+        console.log('[PARSE ERROR] No balanced JSON found in response:', text);
+        throw new Error('Invalid JSON response');
+    }
+
+    let json = text.slice(start, end + 1);
+
+    /* Clean string contents */
+    let result = '';
+    inString = false;
+    escape = false;
+
+    for (let i = 0; i < json.length; i++)
+    {
+        const char = json[i];
+
+        if (escape)
+        {
+            result += char;
+            escape = false;
+            continue;
+        }
+
+        if (char === '\\')
+        {
+            result += char;
+            escape = true;
+            continue;
+        }
+
+        if (char === '"')
+        {
+            inString = !inString;
+            result += char;
+            continue;
+        }
+
+        if (inString)
+        {
+            if (/[\u201C\u201D\u201E\u201F]/.test(char)) { result += '\\"'; continue; }
+            if (/[\u2018\u2019\u201A\u201B]/.test(char)) { result += "'"; continue; }
+            if (char === '\n') { result += '\\n'; continue; }
+            if (char === '\r') { result += '\\r'; continue; }
+            if (char === '\t') { result += '\\t'; continue; }
+        }
+
+        result += char;
+    }
+
+    try
+    {
+        return JSON.parse(result);
+    }
+    catch
+    {
+        /* Fix wrapped strings: "key": { "value" } → "key": "value" */
+        const fixed = result.replace(/:\s*\{\s*("(?:[^"\\]|\\.)*?")\s*\}/g, ': $1');
+
+        try
+        {
+            return JSON.parse(fixed);
+        }
+        catch (error)
+        {
+            console.log('[PARSE ERROR] Raw response:', text);
+            console.log('[PARSE ERROR] Cleaned result:', result);
+            console.log('[PARSE ERROR] Fixed attempt:', fixed);
+            throw error;
+        }
+    }
+});

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

@@ -0,0 +1,218 @@
+import onetype from 'onetype';
+import agents from '#agents/addon.js';
+import providers from '#providers/addon.js';
+
+agents.Fn('item.run', async function(agent, data = {})
+{
+    this.methods.schema = (agent) =>
+    {
+        const schema = {};
+
+        for (const [key, value] of Object.entries(agent.Get('output')))
+        {
+            if (value.populate !== false)
+            {
+                schema[key] = value;
+            }
+        }
+
+        return schema;
+    };
+
+    this.methods.system = (agent) =>
+    {
+        return agent.Get('instructions');
+    };
+
+    this.methods.context = (agent, data) =>
+    {
+        const context = agent.Get('context');
+
+        if (typeof context === 'function')
+        {
+            return context({ data });
+        }
+
+        return context;
+    };
+
+    this.methods.content = async (agent, data) =>
+    {
+        let content = '';
+
+        const context = await this.methods.context(agent, data);
+
+        if (context && Object.keys(context).length > 0)
+        {
+            content += JSON.stringify(context, null, 2) + '\n\n';
+        }
+
+        if (Object.keys(data).length > 0)
+        {
+            content += JSON.stringify(data, null, 2);
+        }
+
+        return content.trim();
+    };
+
+    this.methods.output = (schema) =>
+    {
+        const keys = Object.keys(schema);
+
+        if (keys.length === 0)
+        {
+            return 'Respond with a JSON object.';
+        }
+
+        let text = 'Respond with a single-line JSON object containing:\n';
+
+        for (const [key, field] of Object.entries(schema))
+        {
+            const type = field.type || 'string';
+            const required = field.required === false ? 'optional' : 'required';
+            const description = field.description || '';
+
+            text += `- "${key}" (${type}, ${required})${description ? ': ' + description : ''}\n`;
+        }
+
+        return text.trim();
+    };
+
+    this.methods.example = (schema) =>
+    {
+        const example = {};
+
+        for (const [key, field] of Object.entries(schema))
+        {
+            const type = field.type || 'string';
+
+            if (type === 'number')
+            {
+                example[key] = 0;
+            }
+            else if (type === 'boolean')
+            {
+                example[key] = false;
+            }
+            else if (type === 'array')
+            {
+                example[key] = [];
+            }
+            else if (type === 'object')
+            {
+                example[key] = {};
+            }
+            else
+            {
+                example[key] = '';
+            }
+        }
+
+        return JSON.stringify(example);
+    };
+
+    this.methods.format = () =>
+    {
+        return { type: 'json_object' };
+    };
+
+    this.methods.payload = async (agent, data) =>
+    {
+        const schema = this.methods.schema(agent);
+        const system = this.methods.system(agent);
+        const content = await this.methods.content(agent, data);
+        const output = this.methods.output(schema);
+        const example = this.methods.example(schema);
+        const format = this.methods.format(agent, schema);
+
+        const messages = [
+            { role: 'system', content: system },
+            { role: 'assistant', content: 'What data do you have?' },
+            { role: 'user', content: content },
+            { role: 'assistant', content: 'How should I format my response?' },
+            { role: 'user', content: output + '\n\nExample: ' + example }
+        ];
+
+        return {
+            model: agent.Get('model'),
+            messages,
+            max_tokens: agent.Get('tokens') || 1000,
+            temperature: 0.7,
+            top_p: 0.8,
+            top_k: 20,
+            presence_penalty: 1.5,
+            response_format: format
+        };
+    };
+
+    this.methods.validate = (data, schema, type) =>
+    {
+        if (Object.keys(schema).length === 0)
+        {
+            return data;
+        }
+
+        try
+        {
+            return onetype.DataDefine(data, schema);
+        }
+        catch (error)
+        {
+            throw new Error(`Agent ${type} Error: ${error.message}`);
+        }
+    };
+
+    const validated = this.methods.validate(data, agent.Get('input'), 'Input');
+    const payload = await this.methods.payload(agent, validated);
+
+    const providerId = agent.Get('provider');
+    const provider = providerId ? providers.ItemGet(providerId) : providers.Fn('default');
+
+    if (!provider)
+    {
+        throw new Error(`Provider not found: ${providerId || 'default'}`);
+    }
+
+    try
+    {
+        agent.Get('onRun') && await agent.Get('onRun')({ payload });
+
+        const result = await provider.Fn('request', payload);
+        let parsed = agents.Fn('parse', result.content);
+
+        if (agent.Get('callback'))
+        {
+            await agent.Get('callback')({ input: validated, output: parsed });
+            parsed = this.methods.validate(parsed, agent.Get('output'), 'Output Post-Callback');
+        }
+        else
+        {
+            parsed = this.methods.validate(parsed, agent.Get('output'), 'Output');
+        }
+
+        const missing = Object.keys(agent.Get('output')).filter(k => agent.Get('output')[k].populate !== false && parsed[k] === undefined);
+
+        if (missing.length > 0)
+        {
+            throw new Error(`Missing output fields: ${missing.join(', ')}`);
+        }
+
+        const meta = {
+            time: result.time,
+            tokens: result.tokens,
+            tps: result.tps,
+            reasoning: result.reasoning
+        };
+
+        agent.Get('onSuccess') && await agent.Get('onSuccess')({ payload, parsed, meta });
+
+        parsed._meta = meta;
+
+        return parsed;
+    }
+    catch (error)
+    {
+        agent.Get('onFail') && await agent.Get('onFail')({ payload, error });
+        throw error;
+    }
+});

package/addons/ai/agents/load.js

@@ -0,0 +1,8 @@
+import '#providers/load.js';
+import agents from '#agents/addon.js';
+
+/* Functions */
+import '#agents/functions/parse.js';
+import '#agents/item/functions/run.js';
+
+export default agents;

package/addons/ai/orchestrator/addon.js

@@ -0,0 +1,25 @@
+import onetype from 'onetype';
+
+const orchestrator = onetype.Addon('orchestrator', (addon) =>
+{
+    addon.Field('id', ['string|number']);
+
+    addon.Field('data', ['object', {}]);
+    addon.Field('task', ['string']);
+
+    addon.Field('steps', ['number', 10]);
+    addon.Field('agents', ['array', []]);
+    addon.Field('status', ['string', 'idle']);
+    addon.Field('state', ['object', null]);
+    
+    addon.Field('onDone', ['function', null]);
+    addon.Field('onAgent', ['function', null]);
+    addon.Field('onGoal', ['function', null]);
+    addon.Field('onConclusion', ['function', null]);
+    addon.Field('onStep', ['function', null]);
+    addon.Field('onStop', ['function', null]);
+    addon.Field('onSuccess', ['function', null]);
+    addon.Field('onFail', ['function', null]);
+});
+
+export default orchestrator;

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

@@ -0,0 +1,277 @@
+import onetype from 'onetype';
+import orchestrator from '#orchestrator/addon.js';
+import agents from '#agents/addon.js';
+
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const magenta = (s) => `\x1b[35m${s}\x1b[0m`;
+
+orchestrator.Fn('item.run', async function(item)
+{
+    const state = {
+        data: item.Get('data'),
+        task: item.Get('task'),
+        agents: item.Get('agents').map((agent) =>
+        {
+            agent = agents.ItemGet(agent);
+
+            if(!agent)
+            {
+                return false;
+            }
+
+            return {
+                id: agent.Get('id'),
+                description: agent.Get('description'),
+                config: agent.Get('input')
+            }
+        }).filter(Boolean),
+
+        stop: false,
+        done: false,
+        agent: null,
+        goal: null,
+        input: {},
+        output: {},
+        conclusion: null,
+        summary: null,
+        history: [],
+
+        steps: { count: 0, total: item.Get('steps') },
+        tokens: { input: 0, output: 0 }
+    };
+
+    const prev = { input: 0, output: 0 };
+
+    const tks = () =>
+    {
+        const input = state.tokens.input - prev.input;
+        const output = state.tokens.output - prev.output;
+
+        prev.input = state.tokens.input;
+        prev.output = state.tokens.output;
+
+        return dim(`[${input}in/${output}out]`);
+    };
+
+    const truncate = (s, max = 120) => s.length > max ? s.slice(0, max) + '…' : s;
+
+    console.log('');
+    console.log(bold('ORCHESTRATOR') + dim(` — ${state.task}`));
+    // console.log(dim(`agents: ${state.agents.map(a => a.id).join(', ')}`));
+    console.log(dim(`max steps: ${state.steps.total}`));
+    console.log('');
+
+    item.Set('status', 'running');
+    item.Set('state', state);
+
+    const start = Date.now();
+
+    try
+    {
+        /* Planner */
+
+        const planner = await agents.ItemGet('orchestrator-planner').Fn('run', {
+            prompt: state.task
+        });
+
+        state.plan = planner.tasks;
+        state.tokens.input += planner._meta.tokens.input;
+        state.tokens.output += planner._meta.tokens.output;
+
+        console.log(bold(yellow('PLAN')) + dim(` — ${state.plan.length} tasks`));
+
+        for (const task of state.plan)
+        {
+            console.log(dim(`  [${task.order}] `) + dim(task.task));
+        }
+
+        console.log('');
+
+        /* Achievable */
+
+        const check = await agents.ItemGet('orchestrator-achievable').Fn('run', {
+            tasks: state.plan,
+            agents: state.agents.map(a => ({ id: a.id, description: a.description }))
+        });
+
+        state.tokens.input += check._meta.tokens.input;
+        state.tokens.output += check._meta.tokens.output;
+
+        if (!check.achievable)
+        {
+            const rejected = check.rejected || [];
+
+            console.log(bold(red('NOT ACHIEVABLE')));
+
+            for (const r of rejected)
+            {
+                console.log(red('  ✗ ') + dim(r.task) + dim(` — ${r.reason}`));
+            }
+
+            console.log('');
+
+            item.Set('status', 'failed');
+
+            return state;
+        }
+
+        console.log(bold(green('ACHIEVABLE')));
+        console.log('');
+
+        return state;
+
+        while (state.steps.count < state.steps.total)
+        {
+            if (state.history.length > 0)
+            {
+                await item.Fn('state.done', state);
+
+                const { actions } = state.debug;
+                const pending = actions.filter(a => !a.confirmed).map(a => a.action);
+                const info = dim(` — ${state.debug.confirmed}/${state.debug.total}`) + (pending.length ? dim(` pending: ${pending.join(', ')}`) : '');
+
+                if (state.done)
+                {
+                    console.log(green('  done') + info + ` ${tks()}`);
+                    break;
+                }
+
+                console.log(dim('  done') + info + ` ${tks()}`);
+            }
+
+            if(state.stop)
+            {
+                const onStop = item.Get('onStop');
+
+                if(onStop)
+                {
+                    await onStop({ state });
+                }
+
+                break;
+            }
+
+            state.steps.count++;
+
+            console.log(bold(cyan(`STEP ${state.steps.count}/${state.steps.total}`)));
+
+            /* Agent + Goal */
+
+            await item.Fn('state.agent', state);
+            console.log(yellow('  agent') + dim(` — ${state.agent}`) + ` ${tks()}`);
+            console.log(dim(`  goal  — ${state.goal}`));
+
+            /* Input */
+
+            await item.Fn('state.input', state);
+
+            const fields = Object.keys(state.input);
+
+            if (fields.length > 0)
+            {
+                const pairs = fields.map(k => `${k}: ${JSON.stringify(state.input[k])}`).join(', ');
+                console.log(magenta('  input') + dim(` — ${pairs}`) + ` ${tks()}`);
+            }
+            else
+            {
+                console.log(dim('  input — (none)') + ` ${tks()}`);
+            }
+
+            /* Execute */
+
+            await item.Fn('state.execute', state);
+
+            const keys = Object.keys(state.output);
+            const preview = keys.map(k =>
+            {
+                const v = JSON.stringify(state.output[k]);
+                return `${k}: ${v.length > 60 ? v.slice(0, 60) + '…' : v}`;
+            }).join(', ');
+
+            console.log(cyan('  exec ') + dim(` — ${truncate(preview, 200)}`) + ` ${tks()}`);
+
+            /* Conclusion */
+
+            await item.Fn('state.conclusion', state);
+            console.log(green('  concl') + dim(` — ${state.conclusion}`) + ` ${tks()}`);
+
+            state.history.push({
+                agent: state.agent,
+                step: state.steps.count,
+                goal: state.goal,
+                input: { ...state.input },
+                output: { ...state.output },
+                conclusion: state.conclusion
+            });
+
+            const onStep = item.Get('onStep');
+
+            if(onStep)
+            {
+                await onStep({ state });
+            }
+
+            console.log('');
+        }
+
+        if(state.stop)
+        {
+            item.Set('status', 'stopped');
+
+            return state;
+        }
+
+        if(!state.done)
+        {
+            throw onetype.Error(422, `Max steps (${state.steps.total}) reached without completing task`, {state});
+        }
+
+        /* Summary */
+
+        await item.Fn('state.summary', state);
+
+        const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+        console.log('');
+        console.log(bold(green('COMPLETE')) + dim(` — ${state.steps.count} steps, ${elapsed}s`));
+        console.log(dim(`tokens: ${state.tokens.input}in / ${state.tokens.output}out`));
+        console.log(green('summary') + dim(` — ${state.summary}`));
+        console.log('');
+
+        item.Set('status', 'completed');
+
+        const onSuccess = item.Get('onSuccess');
+
+        if(onSuccess)
+        {
+            await onSuccess({ state });
+        }
+
+        return state;
+    }
+    catch (error)
+    {
+        const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+
+        console.log('');
+        console.log(bold(red('FAILED')) + dim(` — step ${state.steps.count}, ${elapsed}s`));
+        console.log(red(error.message));
+        console.log('');
+
+        item.Set('status', 'failed');
+
+        const onFail = item.Get('onFail');
+
+        if(onFail)
+        {
+            await onFail({ state, error });
+        }
+
+        throw error;
+    }
+});