@onetype/framework 2.0.42 → 2.0.43

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

@@ -1,277 +0,0 @@
-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;
-    }
-});

package/addons/ai/orchestrator/item/functions/state/agent.js

@@ -1,41 +0,0 @@
-import onetype from 'onetype';
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.agent', async function(item, state)
-{
-    const payload = {
-        task: state.task,
-        history: state.history.map((item) =>
-        {
-            return {
-                step: item.step,
-                agent: item.agent,
-                goal: item.goal,
-                conclusion: item.conclusion
-            }
-        }),
-        agents: state.agents
-    };
-
-    const result = await agents.ItemGet('orchestrator-agent').Fn('run', payload);
-
-    if (!state.agents.find((a) => a.id === result.agent))
-    {
-        throw onetype.Error(422, `Agent "${result.agent}" not found in available agents`);
-    }
-
-    state.agent = result.agent;
-    state.goal = result.goal;
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    const onAgent = item.Get('onAgent');
-
-    if(onAgent)
-    {
-        await onAgent({ state, output: result });
-    }
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/conclusion.js

@@ -1,27 +0,0 @@
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.conclusion', async function(item, state)
-{
-    const payload = {
-        task: state.task,
-        goal: state.goal,
-        agent: state.agents.find((entry) => entry.id === state.agent),
-        output: state.output
-    };
-
-    const result = await agents.ItemGet('orchestrator-conclusion').Fn('run', payload);
-
-    state.conclusion = result.conclusion;
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    const onConclusion = item.Get('onConclusion');
-
-    if(onConclusion)
-    {
-        await onConclusion({ state, output: result });
-    }
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/done.js

@@ -1,40 +0,0 @@
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.done', async function(item, state)
-{
-    const agent = agents.ItemGet('orchestrator-done');
-
-    const payload = { 
-        task: state.task, 
-        history: state.history.map((item) => 
-        {
-            return {
-                step: item.step,
-                agent: item.agent,
-                goal: item.goal,
-                conclusion: item.conclusion
-            }
-        }),
-    };
-    
-    const result = await agent.Fn('run', payload);
-
-    state.done = result.done;
-
-    const actions = result.actions || [];
-    const confirmed = actions.filter(a => a.confirmed).length;
-
-    state.debug = { total: actions.length, confirmed, done: result.done, actions };
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    const onDone = item.Get('onDone');
-
-    if(onDone)
-    {
-        await onDone({ state, output: result });
-    }
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/execute.js

@@ -1,16 +0,0 @@
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.execute', async function(item, state)
-{
-    const result = await agents.ItemGet(state.agent).Fn('run', state.input);
-
-    const { _meta, ...output } = result;
-
-    state.output = output;
-
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/goal.js

@@ -1,34 +0,0 @@
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.goal', async function(item, state)
-{
-    const payload = {
-        task: state.task,
-        agent: state.agents.find((item) => item.id === state.agent),
-        history: state.history.map((entry) =>
-        {
-            return {
-                step: entry.step,
-                agent: entry.agent,
-                goal: entry.goal,
-                conclusion: entry.conclusion
-            }
-        })
-    };
-
-    const result = await agents.ItemGet('orchestrator-goal').Fn('run', payload);
-
-    state.goal = result.goal;
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    const onGoal = item.Get('onGoal');
-
-    if(onGoal)
-    {
-        await onGoal({ state, output: result });
-    }
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/input.js

@@ -1,55 +0,0 @@
-import onetype from 'onetype';
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.input', async function(item, state)
-{
-    const agent = agents.ItemGet(state.agent);
-    const schema = agent.Get('input');
-    const fields = Object.keys(schema);
-
-    if (fields.length === 0)
-    {
-        state.input = {};
-        return;
-    }
-
-    const payload = {
-        goal: state.goal,
-        agent: {
-            id: agent.Get('id'),
-            description: agent.Get('description'),
-            config: agent.Get('input')
-        },
-        fields: schema
-    };
-
-    const result = await agents.ItemGet('orchestrator-input').Fn('run', payload);
-
-    const matched = {};
-
-    for (const field of fields)
-    {
-        const value = result.values?.[field];
-
-        if (value === undefined || value === null) continue;
-
-        matched[field] = value;
-    }
-
-    /* Defaults */
-
-    for (const field of fields)
-    {
-        if (matched[field] === undefined && schema[field]?.value !== undefined)
-        {
-            matched[field] = schema[field].value;
-        }
-    }
-
-    state.input = onetype.DataDefine(matched, schema);
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-
-    return result;
-});

package/addons/ai/orchestrator/item/functions/state/summary.js

@@ -1,26 +0,0 @@
-import agents from '#agents/load.js';
-import orchestrator from '#orchestrator/addon.js';
-
-orchestrator.Fn('item.state.summary', async function(item, state)
-{
-    const payload = {
-        task: state.task,
-        history: state.history.map((entry) =>
-        {
-            return {
-                step: entry.step,
-                agent: entry.agent,
-                goal: entry.goal,
-                conclusion: entry.conclusion
-            }
-        })
-    };
-
-    const result = await agents.ItemGet('orchestrator-summary').Fn('run', payload);
-
-    state.summary = result.summary;
-    state.tokens.input += result._meta.tokens.input;
-    state.tokens.output += result._meta.tokens.output;
-    
-    return result;
-});

package/addons/ai/orchestrator/items/agents/achievable.js

@@ -1,37 +0,0 @@
-onetype.AddonReady('agents', (agents) =>
-{
-	agents.Item({
-		id: 'orchestrator-achievable',
-		name: 'Orchestrator Achievable',
-		description: 'Checks if the planned tasks can be executed by the available agents',
-		instructions: `
-			You receive a list of planned tasks and a list of available agents.
-			For each task, determine if the required actions can be performed by the available agents.
-			Agents can be chained, repeated, and used conditionally by an orchestrator.
-			Filtering, looping, and conditional logic are handled by the orchestrator — not by agents.
-			A task is achievable if the underlying actions (list, create, delete, etc.) have matching agents.
-			Only reject when the action type itself has no matching agent.
-		`,
-		tokens: 1000,
-		input: {
-			tasks: {
-				type: 'array',
-				description: 'Planned tasks [{task, order}]'
-			},
-			agents: {
-				type: 'array',
-				description: 'Available agents [{id, description}]'
-			}
-		},
-		output: {
-			achievable: {
-				type: 'boolean',
-				description: 'true if all tasks can be handled by available agents'
-			},
-			rejected: {
-				type: 'array',
-				description: 'Tasks that no agent can handle [{task, reason}]'
-			}
-		}
-	});
-});

package/addons/ai/orchestrator/items/agents/agent.js

@@ -1,46 +0,0 @@
-onetype.AddonReady('agents', (agents) =>
-{
-    agents.Item({
-        id: 'orchestrator-agent',
-        name: 'Orchestrator Agent',
-        description: 'Selects the next agent and writes its goal',
-        instructions: `
-            Pick the next agent and write its goal.
-
-            Read conclusions to know what is done. If data is missing, pick a listing agent first.
-            If data exists, pick the action agent. Complete remaining items of the same type before moving on.
-            Agent ID must exactly match one from the agents list.
-
-            Goal: one action, one target. Include concrete values from conclusions. Never guess.
-        `,
-        tokens: 400,
-        input: {
-            task: {
-                type: 'string',
-                description: 'The original user request'
-            },
-            history: {
-                type: 'array',
-                description: 'Completed steps [{step, agent, goal, conclusion}]'
-            },
-            agents: {
-                type: 'array',
-                description: 'Available agents [{id, description, config}]'
-            }
-        },
-        output: {
-            agent: {
-                type: 'string',
-                description: 'Exact agent ID from the agents list'
-            },
-            reason: {
-                type: 'string',
-                description: 'One sentence: why this agent now'
-            },
-            goal: {
-                type: 'string',
-                description: 'Actionable goal with literal values for the agent'
-            }
-        }
-    });
-});

package/addons/ai/orchestrator/items/agents/conclusion.js

@@ -1,41 +0,0 @@
-onetype.AddonReady('agents', (agents) =>
-{
-    agents.Item({
-        id: 'orchestrator-conclusion',
-        name: 'Orchestrator Conclusion',
-        description: 'Records what happened — the only memory future steps can read',
-        instructions: `
-            You are the orchestrator's memory. Future steps ONLY read your conclusion.
-            Omitted data is lost forever.
-
-            Single dense paragraph. Include every field and value from the output.
-            ALL items if the output is a list. Preserve data relevant to the task and goal.
-            Past tense. Max 60 words.
-        `,
-        tokens: 300,
-        input: {
-            task: {
-                type: 'string',
-                description: 'The original user request'
-            },
-            goal: {
-                type: 'string',
-                description: 'What this step was trying to do'
-            },
-            agent: {
-                type: 'object',
-                description: 'Agent that ran {id, description, config}'
-            },
-            output: {
-                type: 'object',
-                description: 'Raw output from the agent'
-            }
-        },
-        output: {
-            conclusion: {
-                type: 'string',
-                description: 'Dense conclusion with all IDs'
-            }
-        }
-    });
-});

package/addons/ai/orchestrator/items/agents/done.js

@@ -1,40 +0,0 @@
-onetype.AddonReady('agents', (agents) =>
-{
-    agents.Item({
-        id: 'orchestrator-done',
-        name: 'Orchestrator Done',
-        description: 'Checks if the orchestration task has been achieved',
-        instructions: `
-            Determine if the task is fully complete.
-
-            Parse the task into distinct required actions. Only count mutating actions
-            (create, update, delete, add, remove, publish, etc). Listings are not actions.
-
-            For each action, check if a conclusion confirms it succeeded.
-            Scope expands when conclusions reveal multiple items to process.
-
-            done = true ONLY when every required action has a confirming conclusion.
-        `,
-        tokens: 400,
-        input: {
-            task: {
-                type: 'string',
-                description: 'The original user request'
-            },
-            history: {
-                type: 'array',
-                description: 'Completed steps [{step, agent, goal, conclusion}]'
-            }
-        },
-        output: {
-            actions: {
-                type: 'array',
-                description: 'Each required action with its status [{action, confirmed}]'
-            },
-            done: {
-                type: 'boolean',
-                description: 'true when every action is confirmed'
-            }
-        }
-    });
-});