arcane-os 0.60.0 → 0.62.0

package/src/local-ai/config.mjs

@@ -2,9 +2,48 @@ import {readFile, writeFile} from 'node:fs/promises';
 import path from 'node:path';
 import Is from 'strong-type';
 import {ArcaneError, ERROR_CODES, throwIfAborted} from '../errors.mjs';
+import {SD14_MODEL} from './image-models/sd14.mjs';
 
 const is = new Is(false);
-export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama', 'onnx'];
+export const LOCAL_AI_RUNTIME_IDS = ['llama.cpp', 'ollama', 'onnx', 'stable-diffusion.cpp'];
+
+/** Image requirements describe assets without acquiring or loading a model. */
+export function normalizeImageRuntimeRequirement(record) {
+    const backend = record.backend ?? 'auto';
+    if (!['auto', 'metal', 'cpu'].includes(backend)) {
+        throw new ArcaneError(ERROR_CODES.usage, `Unknown stable-diffusion.cpp backend: ${String(backend)}.`);
+    }
+    if (record.models !== undefined && !is.array(record.models)) {
+        throw new ArcaneError(ERROR_CODES.usage, 'stable-diffusion.cpp models must be an array of model IDs or descriptors.');
+    }
+    const models = (record.models ?? []).map(
+        function selectedImageModel(value) {
+            const model = value === 'sd14' ? SD14_MODEL : value;
+            if (!model || !is.object(model) || is.array(model) || !is.string(model.id) || !model.id) {
+                throw new ArcaneError(ERROR_CODES.usage, 'An image model needs a descriptor with an id, or the built-in sd14 ID.');
+            }
+            if (!model.resources || !is.object(model.resources) || is.array(model.resources)) {
+                throw new ArcaneError(ERROR_CODES.usage, `Image model ${model.id} needs resources keyed by model role.`);
+            }
+            if (model.operations !== undefined && !is.array(model.operations)) {
+                throw new ArcaneError(ERROR_CODES.usage, `Image model ${model.id} operations must be an array.`);
+            }
+            return {
+                ...model,
+                resources: {...model.resources},
+                context: {...model.context},
+                defaults: {...model.defaults},
+                operations: [...(model.operations ?? [])]
+            };
+        }
+    );
+    return {
+        ...record,
+        version: record.version ?? 'master-929-3f8527a',
+        backend,
+        models
+    };
+}
 
 /** Runtime requirements are application configuration, separate from models. */
 export function normalizeLocalAIConfig(value) {
@@ -17,6 +56,7 @@ export function normalizeLocalAIConfig(value) {
         if (!record || !LOCAL_AI_RUNTIME_IDS.includes(record.id)) {
             throw new ArcaneError(ERROR_CODES.usage, `Unknown local AI runtime: ${String(record?.id ?? item)}.`);
         }
+        if (record.id === 'stable-diffusion.cpp') return normalizeImageRuntimeRequirement(record);
         return {...record};
     });
     return {...value, runtimes};

package/src/local-ai/dev.mjs

@@ -1,6 +1,8 @@
 import Is from 'strong-type';
 import {createCoreRuntime} from '../core/runtime.mjs';
 import {createLocalAIService} from '../core/services/local-ai.mjs';
+import {createLocalImageService} from '../core/services/image.mjs';
+import {createModelAssetService} from '../core/services/model-assets.mjs';
 import {CORE_PROTOCOL, CoreError, serializeCoreError} from '../../browser-runtime/core/contracts.mjs';
 import {normalizeLocalAIConfig} from './config.mjs';
 import {discoverLocalAIRuntimes} from './discover.mjs';
@@ -81,6 +83,8 @@ export function createDevelopmentLocalAI({config, appRoot, directory, applicatio
     const incoming = new Set();
     let runtime;
     let service;
+    let imageService;
+    let modelAssets;
     let stopFrames;
     let preparationError = null;
     let closing = null;
@@ -157,17 +161,49 @@ export function createDevelopmentLocalAI({config, appRoot, directory, applicatio
         writeFrame(connection, event('core.state', current));
         for (const record of current.services) writeFrame(connection, event('core.service.state', record));
         writeFrame(connection, event('localai.state', service.current()));
+        if (imageService) writeFrame(connection, event('image.state', imageService.current()));
+        if (modelAssets) writeFrame(connection, event('modelAssets.state', modelAssets.current()));
     }
 
-    const ready = Promise.resolve().then(async function prepareLocalAI() {
+    const ready = Promise.resolve().then(function prepareLocalAI() {
         operationSignal.throwIfAborted();
-        const discovered = await discoverLocalAIRuntimes({config: selected, appRoot, signal: operationSignal});
-        operationSignal.throwIfAborted();
-        const installed = await ensureLocalAIRuntimes({runtimes: discovered.missing, directory, signal: operationSignal, onEvent});
-        const runtimes = [...discovered.available, ...installed];
-        operationSignal.throwIfAborted();
-        service = createLocalAIService(selected, {appRoot, runtimes, signal: operationSignal, onEvent});
-        runtime = createCoreRuntime({application, version, services: [service]});
+        const localConfig = {
+            ...selected,
+            runtimes: selected.runtimes.filter(function selectedChatRuntime(requirement) {
+                return requirement.id !== 'stable-diffusion.cpp';
+            })
+        };
+        service = createLocalAIService(
+            localConfig,
+            {
+                appRoot, signal: operationSignal, onEvent,
+                async prepare({signal, onEvent: report}) {
+                    const discovered = await discoverLocalAIRuntimes({config: localConfig, appRoot, signal});
+                    const installed = await ensureLocalAIRuntimes({runtimes: discovered.missing, directory, signal, onEvent: report});
+                    return [...discovered.available, ...installed];
+                }
+            }
+        );
+        const services = [service];
+        if (selected.runtimes.some(function selectedImageRuntime(requirement) {
+            return requirement.id === 'stable-diffusion.cpp';
+        })) {
+            modelAssets = createModelAssetService({appRoot});
+            imageService = createLocalImageService(
+                selected,
+                {
+                    appRoot, modelAssets, signal: operationSignal, onEvent,
+                    async prepare({requirement, signal, onEvent: report}) {
+                        const installed = await ensureLocalAIRuntimes(
+                            {runtimes: [requirement], directory, signal, onEvent: report}
+                        );
+                        return installed[0];
+                    }
+                }
+            );
+            services.push(modelAssets, imageService);
+        }
+        runtime = createCoreRuntime({application, version, services});
         stopFrames = runtime.onFrame(routeFrame);
         runtime.start();
         return runtime;
@@ -350,7 +386,8 @@ export function createDevelopmentLocalAI({config, appRoot, directory, applicatio
     function current() {
         return {state: closed ? 'closed' : preparationError ? 'error' : runtime ? 'ready' : 'preparing',
             error: preparationError ? serializeCoreError(preparationError) : null,
-            core: runtime?.current() ?? null, localAI: service?.current() ?? null};
+            core: runtime?.current() ?? null, localAI: service?.current() ?? null,
+            image: imageService?.current() ?? null};
     }
 
     function close() {