@onetype/framework 2.0.41 → 2.0.42

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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,41 @@
+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

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

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

@@ -0,0 +1,58 @@
+onetype.AddonReady('agents', (agents) =>
+{
+    agents.Item({
+        id: 'orchestrator-goal',
+        name: 'Orchestrator Goal',
+        description: 'Writes a specific goal for the next agent to execute',
+        instructions: `
+            Write a goal for the selected agent.
+
+            You receive:
+            - task: the original user request
+            - agent: the selected agent {id, description}
+            - history: completed steps [{step, agent, goal, conclusion}]
+
+            The goal is the ONLY instruction the agent receives.
+            It is also used to extract literal input values for the agent.
+
+            CRITICAL — ONE ACTION, ONE TARGET:
+            - The agent executes ONCE — one API call, one item
+            - If the task requires deleting 3 pages, the goal is for ONE page only
+            - Read the agent description to know what ONE call can do
+            - Never list multiple IDs or targets in a single goal
+
+            CRITICAL — RESOLVE ALL REFERENCES:
+            - Conclusions contain exact values from previous steps — USE THEM
+            - When the task references something by name, find its EXACT identifier in conclusions
+            - When the task uses relative references (first, last, second), resolve to ACTUAL values from conclusions
+            - NEVER guess or assume any value — only use what conclusions explicitly state
+            - If the value you need is NOT in any conclusion, the goal must describe what to look up
+
+            RULES:
+            - Max 80 words
+            - Include every concrete value the agent needs to execute
+            - Plain text only, no markdown
+        `,
+        tokens: 400,
+        input: {
+            task: {
+                type: 'string',
+                description: 'The full original user request, used to know what the agent should work toward'
+            },
+            agent: {
+                type: 'object',
+                description: 'The selected agent that will execute this goal, with {id, description, config}'
+            },
+            history: {
+                type: 'array',
+                description: 'Chronological list of completed steps, each with {step, agent, goal, conclusion} — use conclusions to resolve concrete values'
+            }
+        },
+        output: {
+            goal: {
+                type: 'string',
+                description: 'A single actionable goal with all literal values the agent needs to execute'
+            }
+        }
+    });
+});

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

@@ -0,0 +1,34 @@
+onetype.AddonReady('agents', (agents) =>
+{
+    agents.Item({
+        id: 'orchestrator-input',
+        name: 'Orchestrator Input',
+        description: 'Extracts input values from the goal text',
+        instructions: `
+            Extract literal values from the goal text for each field.
+            Extract exactly as stated. Plain values only — no objects, no arrays.
+            If the goal has no value for a field, omit it. Better to omit than guess.
+        `,
+        tokens: 300,
+        input: {
+            goal: {
+                type: 'string',
+                description: 'Goal text with concrete values to extract'
+            },
+            agent: {
+                type: 'object',
+                description: 'Target agent {id, description, config}'
+            },
+            fields: {
+                type: 'object',
+                description: 'Fields needing values {name → {type, description}}'
+            }
+        },
+        output: {
+            values: {
+                type: 'object',
+                description: 'Extracted values keyed by field name'
+            }
+        }
+    });
+});

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

@@ -0,0 +1,30 @@
+onetype.AddonReady('agents', (agents) =>
+{
+	agents.Item({
+		id: 'orchestrator-planner',
+		name: 'Orchestrator Planner',
+		description: 'Splits a user prompt into atomic tasks with ordering and parallelism',
+		instructions: `
+			Split the user prompt into logical steps.
+			Each step is a distinct action or group of actions.
+			Do not duplicate steps for unknown quantities — use one step to describe the repeated action.
+
+			For each step:
+			- task: what needs to be done
+			- order: batch number. Steps that need results from earlier steps get a higher number. Independent steps share the same number.
+		`,
+		tokens: 2000,
+		input: {
+			prompt: {
+				type: 'string',
+				description: 'The full user prompt to split into tasks'
+			}
+		},
+		output: {
+			tasks: {
+				type: 'array',
+				description: 'Atomic tasks [{task, order}]'
+			}
+		}
+	});
+});

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

@@ -0,0 +1,29 @@
+onetype.AddonReady('agents', (agents) =>
+{
+    agents.Item({
+        id: 'orchestrator-summary',
+        name: 'Orchestrator Summary',
+        description: 'Final user-facing summary of all actions',
+        instructions: `
+            Summarize what was accomplished across all steps.
+            Concrete results only. Mention failures if any. Max 40 words. Plain text.
+        `,
+        tokens: 200,
+        input: {
+            task: {
+                type: 'string',
+                description: 'The original user request'
+            },
+            history: {
+                type: 'array',
+                description: 'All steps [{step, agent, goal, conclusion}]'
+            }
+        },
+        output: {
+            summary: {
+                type: 'string',
+                description: 'Concise summary of all actions performed'
+            }
+        }
+    });
+});

package/addons/ai/orchestrator/items/chat.js

@@ -0,0 +1,10 @@
+onetype.AddonReady('orchestrator', (orchestrator) =>
+{
+    orchestrator.Item({
+        id: 'chat',
+        task: '',
+        steps: 10,
+        agents: null,
+        data: {}
+    });
+});

package/addons/ai/orchestrator/load.js

@@ -0,0 +1,25 @@
+import orchestrator from '#orchestrator/addon.js';
+
+/* Items */
+import '#orchestrator/items/chat.js';
+import '#orchestrator/items/agents/done.js';
+import '#orchestrator/items/agents/goal.js';
+import '#orchestrator/items/agents/agent.js';
+import '#orchestrator/items/agents/conclusion.js';
+import '#orchestrator/items/agents/input.js';
+import '#orchestrator/items/agents/summary.js';
+import '#orchestrator/items/agents/planner.js';
+import '#orchestrator/items/agents/achievable.js';
+
+
+/* Functions */
+import '#orchestrator/item/functions/state/agent.js';
+import '#orchestrator/item/functions/state/goal.js';
+import '#orchestrator/item/functions/state/done.js';
+import '#orchestrator/item/functions/state/input.js';
+import '#orchestrator/item/functions/state/conclusion.js';
+import '#orchestrator/item/functions/state/execute.js';
+import '#orchestrator/item/functions/state/summary.js';
+import '#orchestrator/item/functions/run.js';
+
+export default orchestrator;

package/addons/ai/providers/addon.js

@@ -0,0 +1,16 @@
+import onetype from 'onetype';
+
+const providers = onetype.Addon('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']);
+});
+
+export default providers;

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

@@ -0,0 +1,14 @@
+import providers from '#providers/addon.js';
+
+providers.Fn('default', function()
+{
+    const items = Object.values(providers.Items());
+    const defaults = items.filter(p => p.Get('default'));
+
+    if (defaults.length === 0)
+    {
+        return items[0] || null;
+    }
+
+    return defaults[Math.floor(Math.random() * defaults.length)];
+});