wizards 0.2.7 → 0.2.9

package/apps/runtime/dist/plugins/events.js

@@ -3,30 +3,24 @@ import { db, schema } from "../db/client.js";
 import { currentTenant } from "../tenants/tenant.js";
 import { pluginsOf } from "./registry.js";
 /**
- * Tells the tenant's plugins that a run reached its end. A plugin cannot fail a run: what a
- * listener throws is logged and nothing more.
+ * Tells the current tenant's plugins what happened. A plugin cannot fail what the runtime does:
+ * what a listener throws is logged and nothing more.
  */
-export async function runEnded(runId, status) {
+export async function emitPluginEvent(event, payload) {
     try {
-        const event = `run.${status}`;
         const listening = (await pluginsOf(currentTenant())).filter((p) => p.listeners[event]?.length);
         if (!listening.length) {
             return;
         }
-        const run = await db.query.run.findFirst({ where: eq(schema.run.id, runId) });
-        const wizard = run && (await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) }));
-        if (!run || !wizard) {
+        // What is costly to gather is gathered only when someone listens.
+        const told = typeof payload === "function" ? await payload() : payload;
+        if (!told) {
             return;
         }
-        const payload = {
-            run: { id: run.id, wizardId: run.wizardId, mode: run.mode, status },
-            wizard: { id: wizard.id, title: run.definition.title, projectId: wizard.projectId },
-            values: run.state.values,
-        };
         for (const plugin of listening) {
             for (const listener of plugin.listeners[event] ?? []) {
                 try {
-                    await listener(payload);
+                    await listener(told);
                 }
                 catch (err) {
                     console.error(`[plugin ${plugin.source.id}] ${event}:`, err);
@@ -35,6 +29,35 @@ export async function runEnded(runId, status) {
         }
     }
     catch (err) {
-        console.error("[plugins] run event:", err);
+        console.error(`[plugins] ${event}:`, err);
     }
 }
+/** A run reached its end. */
+export function runEnded(runId, status) {
+    return emitPluginEvent(`run.${status}`, async () => {
+        const run = await db.query.run.findFirst({ where: eq(schema.run.id, runId) });
+        const wizard = run && (await db.query.wizard.findFirst({ where: eq(schema.wizard.id, run.wizardId) }));
+        if (!run || !wizard) {
+            return null;
+        }
+        return {
+            run: { id: run.id, wizardId: run.wizardId, mode: run.mode, status },
+            wizard: { id: wizard.id, title: run.definition.title, projectId: wizard.projectId },
+            values: run.state.values,
+        };
+    });
+}
+/**
+ * A space was made, changed or deleted. Not waited for: the request that changed the space
+ * answers without its plugins.
+ */
+export function spaceChanged(event, spaceId) {
+    void emitPluginEvent(event, { space: { id: spaceId } });
+}
+/** A file of a space was read and is ready, or was removed. Not waited for either. */
+export function spaceFileChanged(event, file) {
+    void emitPluginEvent(event, {
+        space: { id: file.projectId },
+        file: { id: file.id, name: file.name, kind: file.kind, mime: file.mime },
+    });
+}

package/apps/runtime/dist/plugins/jobs.js

@@ -0,0 +1,64 @@
+import { and, eq } from "drizzle-orm";
+import { control, controlDb, withTenant } from "../db/client.js";
+import { env } from "../env.js";
+import { loadedPlugins, pluginIdsOf } from "./registry.js";
+/**
+ * Plugins' jobs (`server.every`). A tick looks once a minute which job is due for which tenant
+ * and runs it inside that tenant. When a job ran is kept in the control database, so a restart
+ * does not start the count again; a runtime that was off runs a due job once when it starts,
+ * not once per turn it missed.
+ */
+/** Jobs that run right now, by tenant, plugin and name: one turn at a time each. */
+const running = new Set();
+/** Starts every job that is due, and is done when they are. */
+export async function runDueJobs(now = new Date()) {
+    const jobs = loadedPlugins().flatMap((plugin) => [...plugin.jobs].map(([name, job]) => ({ plugin, name, job })));
+    if (!jobs.length) {
+        return;
+    }
+    const tenants = await controlDb.query.tenant.findMany({
+        where: eq(control.tenant.status, "active"),
+    });
+    const started = [];
+    for (const tenant of tenants) {
+        const has = await pluginIdsOf(tenant.id);
+        for (const { plugin, name, job } of jobs) {
+            const id = plugin.source.id;
+            const key = `${tenant.id}/${id}/${name}`;
+            if (!has.has(id) || running.has(key)) {
+                continue;
+            }
+            const where = and(eq(control.pluginJob.tenantId, tenant.id), eq(control.pluginJob.plugin, id), eq(control.pluginJob.name, name));
+            const last = (await controlDb.query.pluginJob.findFirst({ where }))?.lastRunAt ?? null;
+            if (last && now.getTime() - last.getTime() < job.everyMs) {
+                continue;
+            }
+            running.add(key);
+            // The start counts as the run: a turn that throws or hangs is not repeated every minute.
+            await controlDb
+                .insert(control.pluginJob)
+                .values({ tenantId: tenant.id, plugin: id, name, lastRunAt: now })
+                .onConflictDoUpdate({
+                target: [control.pluginJob.tenantId, control.pluginJob.plugin, control.pluginJob.name],
+                set: { lastRunAt: now },
+            });
+            started.push(withTenant(tenant.id, () => job.handler({ tenantId: tenant.id, lastRun: last, signal: plugin.stopped.signal }))
+                .catch((err) => console.error(`[plugin ${id}] job ${name}:`, err))
+                .finally(() => running.delete(key)));
+        }
+    }
+    await Promise.all(started);
+}
+const TICK_MS = 60_000;
+let timer = null;
+/** Looks for due jobs now and then once a minute, while the runtime runs. */
+export function startJobs() {
+    if (timer || !env.plugins.jobs) {
+        return;
+    }
+    const tick = () => void runDueJobs().catch((err) => console.error("[plugins] jobs:", err));
+    // Soon after the start, not during it: tenant databases open first.
+    setTimeout(tick, 5_000).unref();
+    timer = setInterval(tick, TICK_MS);
+    timer.unref();
+}

package/apps/runtime/dist/plugins/loader.js

@@ -4,12 +4,17 @@ import { fileURLToPath } from "node:url";
 import { PLUGIN_TOOL_NAME } from "@engenty-wizards/shared/definition";
 import { generateText, Output } from "ai";
 import { createJiti } from "jiti";
+import { readPage } from "../agents/website.js";
 import { packageRoot } from "../cli/home.js";
 import { db, onTenantOpen } from "../db/client.js";
+import { parseDocument } from "../documents/parse.js";
 import { env } from "../env.js";
 import { ModelUnavailableError, textModel } from "../models.js";
+import { putIndexEntry, removeIndexEntries } from "../services/project-index.js";
+import { safeFetch } from "../tools/net-guard.js";
 import { discoverPlugins } from "./discovery.js";
 import { migrateOpenTenants, migratePlugins } from "./migrations.js";
+import { publicUrlOf } from "./public.js";
 import { announceChange, compileRoute, dropPlugin, emptyRecord, loadedPlugin, loadedPlugins, setPlugin, } from "./registry.js";
 /**
  * Loading plugins (docs/content/dev/plugins). A plugin's server half is TypeScript or JavaScript read
@@ -40,9 +45,21 @@ async function importFactory(entry) {
     }
     return factory;
 }
+/** A job runs at most this often. */
+const MIN_EVERY_MS = 60_000;
 function apiFor(record) {
     const { source } = record;
     const tag = `[plugin ${source.id}]`;
+    /** The names a step's model sees: the plugin's step tools and its context tools share them. */
+    const stepToolNames = () => [
+        ...record.tools.keys(),
+        ...record.contexts.flatMap((c) => (c.tools ?? []).map((t) => t.name)),
+    ];
+    const named = (kind, name) => {
+        if (!PLUGIN_TOOL_NAME.test(name)) {
+            throw new Error(`${kind} "${name}": a name is lower case, digits and "_".`);
+        }
+    };
     return {
         plugin: source.manifest,
         resolvePath: (relative) => resolve(source.root, relative),
@@ -57,14 +74,54 @@ function apiFor(record) {
                 record.routes.push(compileRoute(route));
             },
             registerTool(tool) {
-                if (!PLUGIN_TOOL_NAME.test(tool.name)) {
-                    throw new Error(`Tool "${tool.name}": a name is lower case, digits and "_".`);
-                }
-                if (record.tools.has(tool.name)) {
+                named("Tool", tool.name);
+                if (stepToolNames().includes(tool.name)) {
                     throw new Error(`Tool "${tool.name}" is registered twice.`);
                 }
                 record.tools.set(tool.name, tool);
             },
+            registerSpaceContext(context) {
+                const names = (context.tools ?? []).map((t) => t.name);
+                for (const name of names) {
+                    named("Tool", name);
+                    if (stepToolNames().includes(name) || names.indexOf(name) !== names.lastIndexOf(name)) {
+                        throw new Error(`Tool "${name}" is registered twice.`);
+                    }
+                }
+                record.contexts.push(context);
+            },
+            registerAssistantTool(tool) {
+                named("Assistant tool", tool.name);
+                if (record.assistantTools.has(tool.name)) {
+                    throw new Error(`Assistant tool "${tool.name}" is registered twice.`);
+                }
+                record.assistantTools.set(tool.name, tool);
+            },
+            registerPublicRoute(route) {
+                record.publicRoutes.push(compileRoute(route));
+            },
+            publicUrl: (path) => publicUrlOf(source.id, path),
+            every(name, everyMs, handler) {
+                named("Job", name);
+                if (record.jobs.has(name)) {
+                    throw new Error(`Job "${name}" is registered twice.`);
+                }
+                record.jobs.set(name, { everyMs: Math.max(MIN_EVERY_MS, everyMs), handler });
+            },
+            index: {
+                put: (entry) => putIndexEntry(source.id, entry),
+                remove: (space, key) => removeIndexEntries(source.id, space, key),
+            },
+            web: {
+                fetch: (url, init) => safeFetch(url, init),
+                read: (url, options) => readPage(url, options?.signal),
+            },
+            documents: {
+                async parse(file, options) {
+                    const parsed = await parseDocument(file, { signal: options?.signal });
+                    return { markdown: parsed.markdown, pages: parsed.pages };
+                },
+            },
             registerMigrations(folder) {
                 record.migrations.push(resolve(source.root, folder));
             },
@@ -102,6 +159,8 @@ function apiFor(record) {
 }
 /** Runs what the plugin asked to have undone, the last first. */
 async function dispose(record) {
+    // Its jobs are told to stop; the runtime stops starting them with the record gone.
+    record.stopped.abort();
     for (const undo of record.disposers.splice(0).reverse()) {
         try {
             await undo();
@@ -123,6 +182,10 @@ async function load(source) {
             await dispose(record);
             record.routes = [];
             record.tools.clear();
+            record.contexts = [];
+            record.assistantTools.clear();
+            record.publicRoutes = [];
+            record.jobs.clear();
             record.listeners = {};
             record.migrations = [];
             record.error = err?.message || String(err);

package/apps/runtime/dist/plugins/public.js

@@ -0,0 +1,31 @@
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { control, controlDb } from "../db/client.js";
+import { env } from "../env.js";
+import { currentTenant } from "../tenants/tenant.js";
+/**
+ * Public addresses of plugins (`server.publicUrl`): `/api/public/plugins/<plugin>/<ref>/…`. The
+ * ref names the tenant without giving its id away; one per tenant and plugin, kept for good.
+ */
+/** The full address of a plugin's public route for the current tenant. */
+export async function publicUrlOf(plugin, path) {
+    const tenantId = currentTenant();
+    const where = and(eq(control.pluginAddress.tenantId, tenantId), eq(control.pluginAddress.plugin, plugin));
+    let row = await controlDb.query.pluginAddress.findFirst({ where });
+    if (!row) {
+        await controlDb
+            .insert(control.pluginAddress)
+            .values({ ref: nanoid(24), tenantId, plugin })
+            .onConflictDoNothing();
+        row = (await controlDb.query.pluginAddress.findFirst({ where }));
+    }
+    const rest = path.startsWith("/") ? path : `/${path}`;
+    return `${env.appUrl}/api/public/plugins/${plugin}/${row.ref}${rest === "/" ? "" : rest}`;
+}
+/** The tenant a plugin's public address belongs to. */
+export async function tenantOfAddress(plugin, ref) {
+    const row = await controlDb.query.pluginAddress.findFirst({
+        where: eq(control.pluginAddress.ref, ref),
+    });
+    return row?.plugin === plugin ? row.tenantId : null;
+}

package/apps/runtime/dist/plugins/registry.js

@@ -15,9 +15,14 @@ export function emptyRecord(source) {
         error: null,
         routes: [],
         tools: new Map(),
+        contexts: [],
+        assistantTools: new Map(),
+        publicRoutes: [],
+        jobs: new Map(),
         listeners: {},
         migrations: [],
         disposers: [],
+        stopped: new AbortController(),
     };
 }
 export function setPlugin(record) {

package/apps/runtime/dist/routes/plugin-public.js

@@ -0,0 +1,59 @@
+import { Hono } from "hono";
+import { withTenant } from "../db/client.js";
+import { tenantOfAddress } from "../plugins/public.js";
+import { loadedPlugin, pluginIdsOf } from "../plugins/registry.js";
+import { tenantStatus } from "../tenants/control.js";
+import { answerOf } from "./plugins.js";
+/**
+ * Plugins' public routes (`server.registerPublicRoute`), below `/api/public/plugins/<id>/<ref>`.
+ * Nobody is signed in: the ref names the tenant, and the plugin checks a secret of its own.
+ */
+const notFound = (c) => c.json({ error: "not found", code: "not_found" }, 404);
+async function dispatch(c) {
+    const id = c.req.param("id") ?? "";
+    const ref = c.req.param("ref") ?? "";
+    const tenantId = await tenantOfAddress(id, ref);
+    if (!tenantId || (await tenantStatus(tenantId)) !== "active") {
+        return notFound(c);
+    }
+    const plugin = (await pluginIdsOf(tenantId)).has(id) ? loadedPlugin(id) : undefined;
+    if (!plugin) {
+        return notFound(c);
+    }
+    const url = new URL(c.req.url);
+    const marker = `/plugins/${id}/${ref}`;
+    const path = url.pathname.slice(url.pathname.indexOf(marker) + marker.length);
+    for (const { route, pattern, params } of plugin.publicRoutes) {
+        const match = route.method === c.req.method ? pattern.exec(path) : null;
+        if (!match) {
+            continue;
+        }
+        const request = {
+            request: c.req.raw,
+            path: path || "/",
+            params: Object.fromEntries(params.map((name, i) => [name, decodeURIComponent(match[i + 1])])),
+            query: url.searchParams,
+            tenantId,
+            json: async () => {
+                const text = await c.req.text();
+                return (text ? JSON.parse(text) : {});
+            },
+        };
+        try {
+            const result = await withTenant(tenantId, () => route.handler(request));
+            return result instanceof Response ? result : c.json(result ?? null);
+        }
+        catch (err) {
+            const answer = answerOf(err);
+            if (answer) {
+                return c.json(answer.body, answer.status);
+            }
+            console.error(`[plugin ${id}] public ${route.method} ${path}:`, err);
+            return c.json({ error: "The plugin failed.", code: "plugin_failed" }, 500);
+        }
+    }
+    return notFound(c);
+}
+export const publicPluginRoutes = new Hono()
+    .all("/:id/:ref", dispatch)
+    .all("/:id/:ref/*", dispatch);

package/apps/runtime/dist/routes/plugins.js

@@ -29,7 +29,7 @@ function view(plugin) {
     };
 }
 /** A thrown error that says how to answer: `{ status, code }`, as the runtime's own errors do. */
-function answerOf(err) {
+export function answerOf(err) {
     const e = err;
     return typeof e?.status === "number" &&
         e.status >= 400 &&

package/apps/runtime/dist/routes/studio.js

@@ -2,6 +2,7 @@ import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { MODEL_CLASSES, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
+import { isCreditsRef } from "@engenty-wizards/shared/providers";
 import { generateText } from "ai";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -22,8 +23,9 @@ import { detectHarness, detectHarnesses, HARNESS_IDS, harness, installSpec, } fr
 import { closeTerminal, openTerminal, resizeTerminal, subscribeTerminal, writeTerminal, } from "../harness/terminal.js";
 import { managed } from "../manage.js";
 import { seenApps } from "../mcp/seen.js";
+import { generateImageMedia, generateSpeechMedia, generateVideoMedia } from "../media/generate.js";
 import { transcribeAudio } from "../media/transcribe.js";
-import { embeddingModel, hasTextModel, LOCAL_KEYS, localModelSettings, ModelUnavailableError, saveLocalModels, textModel, } from "../models.js";
+import { checkKey, classProblem, embeddingModel, hasTextModel, LOCAL_KEYS, localModelSettings, ModelUnavailableError, modelSettings, saveLocalModels, saveModels, storedKey, textModel, } from "../models.js";
 import { HTML_RESPONSE_CSP } from "../render/guard.js";
 import { mayBuild, projectWritable, requireWritable } from "../services/access.js";
 import { architectTurn } from "../services/architect.js";
@@ -60,6 +62,113 @@ async function setupDone() {
     }
     return hasTextModel();
 }
+const modelsInput = z.object({
+    source: z.enum([...HARNESS_IDS, "account", "own"]).optional(),
+    bindings: z.partialRecord(z.enum(MODEL_CLASSES), z.string().max(160)).optional(),
+    ollamaUrl: z.string().max(200).optional(),
+    creditFallback: z.boolean().optional(),
+    keys: z.partialRecord(z.enum(LOCAL_KEYS), z.string().max(400)).optional(),
+});
+/** Alone the person changes everything; in a team its owner and admins. */
+function mayChangeModels(user) {
+    return !managed || user.role === "owner" || user.role === "admin";
+}
+/** A binding the cloud can run: a provider's model or the credits, no client, no local model. */
+function cloudBinding(ref) {
+    return (isCreditsRef(ref) || /^(openai|anthropic|google|fal|elevenlabs|replicate|gateway):/.test(ref));
+}
+const TEST_TEXT = {
+    de: {
+        image: "Ein kleiner, freundlicher Zauberhut aus orangem Filz auf einem Holztisch, weiches Licht, flache Illustration.",
+        speech: "Hallo! So klingt die Stimme deiner Wizards.",
+        video: "Ein orangefarbener Zauberhut dreht sich langsam auf einem Holztisch, weiches Licht.",
+    },
+    en: {
+        image: "A small, friendly wizard hat of orange felt on a wooden table, soft light, flat illustration.",
+        speech: "Hello! This is how your wizards sound.",
+        video: "An orange wizard hat slowly turns on a wooden table, soft light.",
+    },
+};
+const asDataUrl = (bytes, mime) => `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`;
+/** One second of silence as WAV: what a voice note test listens to where nothing speaks. */
+function silentWav() {
+    const rate = 16_000;
+    const samples = rate;
+    const buf = Buffer.alloc(44 + samples * 2);
+    buf.write("RIFF", 0);
+    buf.writeUInt32LE(36 + samples * 2, 4);
+    buf.write("WAVEfmt ", 8);
+    buf.writeUInt32LE(16, 16);
+    buf.writeUInt16LE(1, 20);
+    buf.writeUInt16LE(1, 22);
+    buf.writeUInt32LE(rate, 24);
+    buf.writeUInt32LE(rate * 2, 28);
+    buf.writeUInt16LE(2, 32);
+    buf.writeUInt16LE(16, 34);
+    buf.write("data", 36);
+    buf.writeUInt32LE(samples * 2, 40);
+    return new Uint8Array(buf);
+}
+async function testClass(cls, lang) {
+    const started = Date.now();
+    const signal = AbortSignal.timeout(cls === "video" ? 300_000 : 120_000);
+    const done = (result) => ({
+        ok: true,
+        ms: Date.now() - started,
+        ...result,
+    });
+    try {
+        if (TEXT_CLASSES.includes(cls)) {
+            const resolved = await textModel(cls);
+            const result = await generateText({
+                model: resolved.model,
+                prompt: "Reply with the single word: OK",
+                maxOutputTokens: 20,
+                abortSignal: signal,
+            });
+            return done({ ref: resolved.ref, reply: result.text.trim().slice(0, 200) });
+        }
+        if (cls === "image") {
+            const image = await generateImageMedia({
+                prompt: TEST_TEXT[lang].image,
+                aspectRatio: "1:1",
+                abortSignal: signal,
+            });
+            return done({ ref: image.system, media: asDataUrl(image.bytes, image.mime) });
+        }
+        if (cls === "speech") {
+            const voice = await generateSpeechMedia({
+                text: TEST_TEXT[lang].speech,
+                abortSignal: signal,
+            });
+            return done({ ref: voice.system, media: asDataUrl(voice.bytes, voice.mime) });
+        }
+        if (cls === "video") {
+            const clip = await generateVideoMedia({
+                prompt: TEST_TEXT[lang].video,
+                aspectRatio: "16:9",
+                duration: 4,
+                resolution: "480p",
+                abortSignal: signal,
+            });
+            return done({ ref: clip.system, media: asDataUrl(clip.bytes, clip.mime) });
+        }
+        // A voice note: the test voice where one speaks here, else a second of silence.
+        const voice = (await classProblem("speech"))
+            ? null
+            : await generateSpeechMedia({ text: TEST_TEXT[lang].speech, abortSignal: signal }).catch(() => null);
+        const heard = await transcribeAudio({
+            bytes: voice?.bytes ?? silentWav(),
+            mediaType: voice?.mime ?? "audio/wav",
+            abortSignal: signal,
+        });
+        return done({ reply: heard.text.slice(0, 300) });
+    }
+    catch (err) {
+        const message = err?.message ?? String(err);
+        return { ok: false, ms: Date.now() - started, error: message.slice(0, 500) };
+    }
+}
 /** The size of an inline terminal, as the page lays it out. */
 const terminalSize = z.object({
     cols: z.number().int().min(10).max(500).optional(),
@@ -276,6 +385,9 @@ export const studio = new Hono()
                 onChanged: () => {
                     void stream.writeSSE({ event: "changed", data: "1" });
                 },
+                onCard: (card) => {
+                    void stream.writeSSE({ event: "card", data: JSON.stringify(card) });
+                },
             });
             await stream.writeSSE({
                 event: "done",
@@ -617,16 +729,49 @@ export const studio = new Hono()
     if (managed) {
         return c.notFound();
     }
-    const body = z
-        .object({
-        source: z.enum([...HARNESS_IDS, "account", "own"]).optional(),
-        bindings: z.partialRecord(z.enum(MODEL_CLASSES), z.string().max(120)).optional(),
-        ollamaUrl: z.string().max(200).optional(),
-        keys: z.partialRecord(z.enum(LOCAL_KEYS), z.string().max(400)).optional(),
-    })
-        .parse(await c.req.json());
-    await saveLocalModels(body);
+    await saveLocalModels(modelsInput.parse(await c.req.json()));
     return c.json(localModelSettings());
+})
+    // --- models: where each class runs, own API keys, the credits behind them -----------------
+    // Alone for this machine; on a Manage-App's runtime for the team, whose admins change it.
+    .get("/models", async (c) => c.json(await modelSettings()))
+    .put("/models", async (c) => {
+    if (!mayChangeModels(c.get("user"))) {
+        return c.json({ error: "Only an admin of the team changes its models." }, 403);
+    }
+    const input = modelsInput.parse(await c.req.json());
+    // In the cloud nothing runs on a machine's client or local model.
+    if (managed &&
+        (input.source ||
+            input.ollamaUrl ||
+            Object.values(input.bindings ?? {}).some((ref) => ref && !cloudBinding(ref)))) {
+        return c.json({ error: "Not available in the cloud." }, 400);
+    }
+    await saveModels(input);
+    return c.json(await modelSettings());
+})
+    // Whether a provider takes a key — the one typed, or the one stored. Nothing is generated.
+    .post("/models/keys/:provider/check", async (c) => {
+    const provider = z.enum(LOCAL_KEYS).parse(c.req.param("provider"));
+    const { key } = z
+        .object({ key: z.string().max(400).optional() })
+        .parse(await c.req.json().catch(() => ({})));
+    const value = key?.trim() || (await storedKey(provider));
+    if (!value) {
+        return c.json({ ok: false, message: "Kein API Key hinterlegt." });
+    }
+    return c.json(await checkKey(provider, value));
+})
+    // One call on a class, as a run makes it: text answers a word, an image, a voice or a short
+    // clip comes back to look at, a voice note comes back as text. Paid like any call.
+    .post("/models/test", async (c) => {
+    if (!mayChangeModels(c.get("user"))) {
+        return c.json({ error: "Only an admin of the team tests its models." }, 403);
+    }
+    const { cls, lang } = z
+        .object({ cls: z.enum(MODEL_CLASSES), lang: z.enum(["de", "en"]).default("de") })
+        .parse(await c.req.json());
+    return c.json(await testClass(cls, lang));
 })
     // One short call on a class, as a run would make it: shows that the way to the model is open.
     .post("/local/models/test", async (c) => {

package/apps/runtime/dist/services/project-files.js

@@ -5,6 +5,7 @@ import { db, schema } from "../db/client.js";
 import { documentMime, UnreadableDocument } from "../documents/parse.js";
 import { loadAsset, removeAsset, saveAsset } from "../files/storage.js";
 import { textModel } from "../models.js";
+import { spaceFileChanged } from "../plugins/events.js";
 import { dropLinks, putLink } from "../tenants/control.js";
 import { requireWritableProject } from "./access.js";
 import { notFound, ServiceError } from "./errors.js";
@@ -192,11 +193,13 @@ async function prepare(row) {
             if (row.kind !== "document") {
                 const description = await describeImage(row, data).catch(() => "");
                 await set({ status: "ready", ...(description ? { description } : {}) });
+                spaceFileChanged("space.file.ready", row);
                 return;
             }
             const { text, ...indexed } = await indexDocument(row, data);
             const description = row.description || (text ? await describeDocument(row, text).catch(() => "") : "");
             await set({ ...indexed, status: "ready", error: null, description });
+            spaceFileChanged("space.file.ready", row);
         }
         catch (err) {
             console.error("[project-file]", row.name, err);
@@ -259,6 +262,7 @@ async function removeRow(row) {
     if (row.kind === "logo") {
         await dropLinks([row.id]);
     }
+    spaceFileChanged("space.file.removed", row);
 }
 export async function removeProjectFile(projectId, fileId) {
     await requireWritableProject(projectId);