@onetype/framework 2.0.41 → 2.0.42

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

@@ -0,0 +1,62 @@
+import providers from '#providers/addon.js';
+
+providers.Fn('item.request', async function(provider, payload)
+{
+    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 });
+
+    const attempt = async (retry) =>
+    {
+        try
+        {
+            const start = Date.now();
+
+            const timeout = provider.Get('timeout') || 120000;
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeout);
+
+            const response = await fetch(provider.Get('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}`);
+            }
+
+            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
+            };
+        }
+        catch (error)
+        {
+            if (retry)
+            {
+                return await attempt(false);
+            }
+
+            throw error;
+        }
+    };
+
+    return await attempt(true);
+});

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

@@ -0,0 +1,98 @@
+onetype.AddonReady('providers', (providers) =>
+{
+    providers.Item({
+        id: 'nue',
+        name: 'Nue Tools',
+        default: true,
+        endpoint: 'https://nue.tools.divhunt.com/api/run/ai-chat',
+        key: 'NUE_API_KEY',
+        model: 'qwen3-next-80b-a3b-thinking',
+        models: {
+            'qwen3-next-80b-a3b-thinking': {
+                tokens: 32768,
+                thinking: true,
+                price: { input: 0, output: 0 }
+            }
+        },
+        onBeforeRequest: ({ payload, key }) =>
+        ({
+            headers: {
+                'Content-Type': 'application/json',
+                ...(key && { 'Authorization': `Bearer ${key}` })
+            },
+            body: payload
+        }),
+        onAfterRequest: ({ response }) =>
+        {
+            const data = response.data || {};
+            let text = (data.response || '').trim();
+
+            let reasoning = (data.reasoning || '').trim() || null;
+
+            if (!reasoning)
+            {
+                const match = text.match(/<think>([\s\S]*?)<\/think>/i);
+
+                if (match)
+                {
+                    reasoning = match[1].trim();
+                    text = text.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+                }
+                else if (text.includes('<think>'))
+                {
+                    /* Handle unclosed think tag */
+                    const idx = text.indexOf('<think>');
+                    reasoning = text.slice(idx + 7).trim();
+                    text = text.slice(0, idx).trim();
+                }
+            }
+
+            const usage = data.usage || {};
+
+            return {
+                content: text,
+                reasoning,
+                tokens: {
+                    input: usage.prompt_tokens || 0,
+                    output: usage.completion_tokens || 0
+                }
+            };
+        }
+    });
+
+    providers.Item({
+        id: 'ollama',
+        name: 'Ollama',
+        default: false,
+        endpoint: 'http://localhost:11434/v1/chat/completions',
+        model: 'qwen3-coder-next:cloud',
+        models: {
+            'qwen3-coder-next:cloud': {
+                tokens: 32768,
+                price: { input: 0, output: 0 }
+            }
+        },
+        onBeforeRequest: ({ payload }) =>
+        ({
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: payload
+        }),
+        onAfterRequest: ({ response }) =>
+        {
+            const choice = response.choices?.[0] || {};
+            const text = (choice.message?.content || '').trim();
+            const usage = response.usage || {};
+
+            return {
+                content: text,
+                reasoning: null,
+                tokens: {
+                    input: usage.prompt_tokens || 0,
+                    output: usage.completion_tokens || 0
+                }
+            };
+        }
+    });
+});

package/addons/ai/providers/load.js

@@ -0,0 +1,10 @@
+import providers from '#providers/addon.js';
+
+/* Items */
+import '#providers/items/nue.js';
+
+/* Functions */
+import '#providers/functions/default.js';
+import '#providers/item/functions/request.js';
+
+export default providers;

package/addons/render/elements/front/functions/runtime.js

@@ -0,0 +1,25 @@
+elements.Fn('runtime', function()
+{
+	this.methods.render = () =>
+	{
+		elements.Render('body', () =>
+		{
+			return document.body.outerHTML;
+		});
+
+		const render = elements.Render('body', window);
+		document.body.replaceChildren(...render.Element.children);
+	};
+
+	if(document.readyState === 'loading')
+	{
+		document.addEventListener('DOMContentLoaded', () =>
+		{
+			this.methods.render();
+		});
+	}
+	else
+	{
+		this.methods.render();
+	}
+});

package/lib/browser.js

@@ -1,25 +1,2 @@
 window.onetype = new OneType();
-window.$ot = onetype.$ot;
-
-if (document.readyState === 'loading')
-{
-    document.addEventListener('DOMContentLoaded', initBrowser);
-}
-else
-{
-    initBrowser();
-}
-
-function initBrowser()
-{
-    onetype.Addon('browser', function(addon)
-    {
-        addon.Render('body', () =>
-        {
-            return document.body.outerHTML;
-        });
-
-        const render = addon.Render('body', window);
-        document.body.replaceChildren(...render.Element.children);
-    });
-}
+window.$ot = onetype.$ot;

package/lib/items/directives/160-slot.js

@@ -22,7 +22,7 @@ directives.ItemAdd({
         else if (slot && slot.html && slot.data)
         {
             const compiled = item.Compile(slot.html, slot.data);
-            node.replaceWith(compiled.element);
+            node.replaceWith(...compiled.element.childNodes);
         }
         else
         {

package/lib/items/directives/500-click-outside.js

@@ -1,50 +1,50 @@
-directives.ItemAdd({
-    id: 'ot-click-outside',
-    icon: 'close_fullscreen',
-    name: 'Click Outside',
-    description: 'Detect clicks outside the element. Perfect for closing dropdowns and modals.',
-    category: 'events',
-    trigger: 'node',
-    order: 500,
-    attributes: {
-        'ot-click-outside': ['string']
-    },
-    code: function(data, item, compile, node, identifier)
-    {
-        const attribute = data['ot-click-outside'].value;
+onetype.AddonReady('directives', function()
+{
+	const handlers = new Set();
 
-        const handler = (event) =>
-        {
-            const results = onetype.Function(attribute, compile.data, false);
+	document.addEventListener('click', function(event)
+	{
+		handlers.forEach((entry) =>
+		{
+			if(!document.contains(entry.element))
+			{
+				handlers.delete(entry);
+				return;
+			}
 
-            if(typeof results === 'function')
-            {
-                results(event, {item, compile, node, identifier});
-            }
-        };
+			if(!entry.element.contains(event.target) && entry.element !== event.target)
+			{
+				entry.handler(event);
+			}
+		});
+	});
 
-        handlers.add({element: node, handler});
-    }
-});
+	directives.ItemAdd({
+		id: 'ot-click-outside',
+		icon: 'close_fullscreen',
+		name: 'Click Outside',
+		description: 'Detect clicks outside the element.',
+		category: 'events',
+		trigger: 'node',
+		order: 500,
+		attributes: {
+			'ot-click-outside': ['string']
+		},
+		code: function(data, item, compile, node, identifier)
+		{
+			const attribute = data['ot-click-outside'].value;
 
-onetype.AddonReady('directives', function()
-{
-    const handlers = new Set();
+			const handler = (event) =>
+			{
+				const results = onetype.Function(attribute, compile.data, false);
 
-    document.addEventListener('click', function(event)
-    {
-        handlers.forEach(({element, handler}) =>
-        {
-            if(!document.contains(element))
-            {
-                handlers.delete({element, handler});
-                return;
-            }
+				if(typeof results === 'function')
+				{
+					results(event, {item, compile, node, identifier});
+				}
+			};
 
-            if(!element.contains(event.target) && element !== event.target)
-            {
-                handler(event);
-            }
-        });
-    });
+			handlers.add({element: node, handler});
+		}
+	});
 });