wizards 0.2.16 → 0.2.18

package/apps/runtime/dist/models.js

@@ -600,6 +600,44 @@ export async function embeddingModel() {
         ? { model: gatewayClient(access, {}).embeddingModel("wizards/embedding"), ref: bound.model }
         : null;
 }
+/**
+ * The way to TypeSafe's Jev, a classifier that answers typed questions with probabilities and
+ * writes no text: the credits on a Manage-App's runtime; alone, an AI Gateway key, a TypeSafe
+ * key, or the linked account's credits. Null when there is none.
+ */
+export async function systemOneAccess() {
+    const cfg = await config();
+    const viaCredits = (access) => ({
+        url: `${access.baseUrl}/v4/ai/systemone`,
+        headers: {
+            authorization: `Bearer ${access.token}`,
+            // Booked under the classifier class; its evaluation model answers.
+            "ai-model-id": "wizards/classifier",
+            ...(access.tenant ? { "x-wizards-tenant": access.tenant } : {}),
+        },
+        model: null,
+    });
+    if (managed) {
+        const access = await creditAccess(cfg, true).catch(() => null);
+        return access ? viaCredits(access) : null;
+    }
+    if (cfg.keys.gateway) {
+        return {
+            url: "https://ai-gateway.vercel.sh/typesafe/v1/systemone",
+            headers: { authorization: `Bearer ${cfg.keys.gateway}` },
+            model: "typesafe-ai/jev",
+        };
+    }
+    if (env.typesafeKey) {
+        return {
+            url: "https://api.typesafe.ai/v1/systemone",
+            headers: { authorization: `Bearer ${env.typesafeKey}` },
+            model: "jev-latest",
+        };
+    }
+    const access = await creditAccess(cfg, false).catch(() => null);
+    return access ? viaCredits(access) : null;
+}
 /** Search tools an AI Gateway runs itself; they travel in the request, so any gateway client names them. */
 export const gatewayTools = createGateway({ apiKey: "unused" }).tools;
 /**

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

@@ -11,6 +11,7 @@ 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 { originData } from "../services/space-origin.js";
 import { safeFetch } from "../tools/net-guard.js";
 import { discoverPlugins } from "./discovery.js";
 import { migrateOpenTenants, migratePlugins } from "./migrations.js";
@@ -112,6 +113,7 @@ function apiFor(record) {
                 put: (entry) => putIndexEntry(source.id, entry),
                 remove: (space, key) => removeIndexEntries(source.id, space, key),
             },
+            spaceData: originData(source.id),
             web: {
                 fetch: (url, init) => safeFetch(url, init),
                 read: (url, options) => readPage(url, options?.signal),

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

@@ -1,6 +1,7 @@
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { MODEL_CLASSES, TEXT_CLASSES } from "@engenty-wizards/shared/definition";
+import { CATEGORY_TYPES, whereSchema } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_FILE_KINDS } from "@engenty-wizards/shared/projects";
 import { isCreditsRef } from "@engenty-wizards/shared/providers";
 import { generateText } from "ai";
@@ -16,7 +17,7 @@ import { layout } from "../cli/home.js";
 import { connectorImportSchema, importConnector, listConnectors, previewSource, refreshConnector, registryService, removeConnector, searchRegistry, } from "../connectors/external.js";
 import { balanceCredits, canSpend } from "../credits/credits.js";
 import { estimateRun } from "../credits/estimate.js";
-import { missingModels } from "../engine/requirements.js";
+import { missingModels, stepsWithoutModel } from "../engine/requirements.js";
 import { env } from "../env.js";
 import { freshAuth, loginEnv } from "../harness/env.js";
 import { detectHarness, detectHarnesses, HARNESS_IDS, harness, installSpec, } from "../harness/index.js";
@@ -30,15 +31,18 @@ import { HTML_RESPONSE_CSP } from "../render/guard.js";
 import { mayBuild, projectWritable, requireWritable } from "../services/access.js";
 import { architectTurn } from "../services/architect.js";
 import { checkForCloud, cloudLinked, cloudSpaces, cloudState, forgetCloud, publishAndSync, pushSharing, removeFromCloud, replaceCloudSpaces, rotateInCloud, syncToCloud, } from "../services/cloud.js";
-import { ServiceError } from "../services/errors.js";
+import { notFound, ServiceError } from "../services/errors.js";
 import { deleteFile, listFiles, readFile, writeFile } from "../services/files.js";
+import { categoryContents, listKnowledge, resolvePath, valueContents, } from "../services/knowledge.js";
+import { writeSummary } from "../services/knowledge-model.js";
 import { exportWizard, importWizard, PACKAGE_EXTENSION, PACKAGE_MAX_BYTES, PACKAGE_MIME, } from "../services/package.js";
 import { profileSchema, saveProfile, userProfile } from "../services/profile.js";
 import { addProjectFile, fileView, orderProjectFiles, projectFile, projectFileContent, projectFiles, reindexProjectFile, removeProjectFile, updateProjectFile, } from "../services/project-files.js";
-import { documentText, searchProject } from "../services/project-index.js";
+import { documentText, queueIndex, searchKnowledge } from "../services/project-index.js";
 import { createProject, deleteProject, listProjects, maskedServers, ownedProject, projectLimit, projectPatchSchema, updateProject, } from "../services/projects.js";
 import { listResults, listRuns, startTestRun } from "../services/runs.js";
-import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
+import { addCategoryValue, categoryRow, categoryValue, deleteCategory, deleteCategoryValue, mergeCategoryValues, orderCategoryValues, putCategory, renameCategoryValue, setItemCategory, updateCategory, } from "../services/space-categories.js";
+import { addTableRow, createPage, createTable, deletePage, deleteTable, deleteTableRows, getPage, getTable, listSpaceData, orderSubPages, updatePage, updateTable, updateTableRow, } from "../services/space-data.js";
 import { draftWidgetPreview } from "../services/widgets.js";
 import { createWizard, deleteWizard, duplicateWizard, listWizards, ownedWizard, rotateShareLink, updateWizardSettings, wizardMessages, wizardState, writableWizard, writeDraft, } from "../services/wizards.js";
 import { readSetting, writeSetting } from "../settings.js";
@@ -344,11 +348,13 @@ export const studio = new Hono()
     const text = await documentText(row);
     return c.json({ text: text.slice(0, limit), chars: text.length });
 })
-    // What the document index finds for a question: the passages an agent step would get.
+    // What a search of Wissen finds for a question: the items an agent step would get.
     .post("/projects/:id/search", async (c) => {
     const project = await ownedProject(c.get("user").id, c.req.param("id"));
-    const { query } = z.object({ query: z.string().min(1).max(400) }).parse(await c.req.json());
-    return c.json({ hits: await searchProject(project.id, query, 6) });
+    const body = z
+        .object({ query: z.string().min(1).max(400), where: whereSchema.optional() })
+        .parse(await c.req.json());
+    return c.json(await searchKnowledge(project.id, body.query, { where: body.where }));
 })
     // The assistant fills the project in: from a description, a website, the files given.
     .post("/projects/:id/assist", async (c) => {
@@ -362,6 +368,7 @@ export const studio = new Hono()
             .array(z.object({ role: z.enum(["user", "assistant"]), content: z.string().max(8000) }))
             .max(24)
             .default([]),
+        part: z.enum(["info", "knowledge"]).default("info"),
     })
         .parse(await c.req.json());
     if (!(await canSpend())) {
@@ -376,6 +383,7 @@ export const studio = new Hono()
                 projectId: project.id,
                 message: body.message,
                 history: body.history,
+                part: body.part,
                 signal: abort.signal,
                 onText: (delta) => {
                     void stream.writeSSE({ event: "text", data: JSON.stringify(delta) });
@@ -466,6 +474,128 @@ export const studio = new Hono()
         mode: query.mode,
         days: query.days,
     }));
+})
+    // --- Wissen: its items and Kategorien ---------------------------------------
+    .get("/projects/:id/knowledge", async (c) => c.json(await listKnowledge(c.get("user").id, c.req.param("id"))))
+    // What a link in a page names (`pages/bgb/p-281`): the studio opens it.
+    .get("/projects/:id/resolve", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    const found = await resolvePath(project.id, z.string().max(600).parse(c.req.query("path")));
+    if (!found) {
+        throw notFound();
+    }
+    return c.json(found);
+})
+    .post("/projects/:id/categories", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await requireWritable(project);
+    const body = z
+        .object({
+        name: z.string().min(1).max(80),
+        type: z.enum(CATEGORY_TYPES),
+        unit: z.string().max(20).nullish(),
+        multiple: z.boolean().optional(),
+        ordered: z.boolean().optional(),
+        hint: z.string().max(120).nullish(),
+        values: z.array(z.string().max(200)).max(200).optional(),
+        tableId: z.string().nullish(),
+        columnId: z.string().nullish(),
+    })
+        .parse(await c.req.json());
+    const row = await putCategory(project.id, body);
+    return c.json({ id: row.id });
+})
+    .patch("/categories/:id", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const body = z
+        .object({
+        name: z.string().min(1).max(80).optional(),
+        unit: z.string().max(20).nullish(),
+        multiple: z.boolean().optional(),
+        ordered: z.boolean().optional(),
+        hint: z.string().max(120).nullish(),
+        proposed: z.literal(false).optional(),
+        position: z.number().int().min(0).optional(),
+    })
+        .parse(await c.req.json());
+    await updateCategory(row.id, body);
+    return c.json({ ok: true });
+})
+    .delete("/categories/:id", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    await deleteCategory(row.id);
+    return c.json({ ok: true });
+})
+    .post("/categories/:id/values", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const { value } = z.object({ value: z.string().min(1).max(200) }).parse(await c.req.json());
+    return c.json(await addCategoryValue(row.id, value));
+})
+    .put("/categories/:id/values/order", async (c) => {
+    const row = await categoryRow(c.req.param("id"));
+    await ownedProject(c.get("user").id, row.projectId);
+    const { ids } = z.object({ ids: z.array(z.string()).max(500) }).parse(await c.req.json());
+    await orderCategoryValues(row.id, ids);
+    return c.json({ ok: true });
+})
+    .get("/values/:id", async (c) => c.json(await valueContents(c.get("user").id, c.req.param("id"))))
+    // Everything that has a Kategorie: the entries its page lists.
+    .get("/categories/:id/items", async (c) => c.json(await categoryContents(c.get("user").id, c.req.param("id"))))
+    .patch("/values/:id", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    const { value } = z.object({ value: z.string().min(1).max(200) }).parse(await c.req.json());
+    await renameCategoryValue(c.req.param("id"), value);
+    return c.json({ ok: true });
+})
+    .post("/values/:id/merge", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    const { into } = z.object({ into: z.string() }).parse(await c.req.json());
+    await mergeCategoryValues(c.req.param("id"), into);
+    return c.json({ ok: true });
+})
+    .delete("/values/:id", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    await ownedProject(c.get("user").id, category.projectId);
+    await deleteCategoryValue(c.req.param("id"));
+    return c.json({ ok: true });
+})
+    // The Übersicht of a value: a model writes it from the value's items.
+    .post("/values/:id/summary", async (c) => {
+    const { category } = await categoryValue(c.req.param("id"));
+    const project = await ownedProject(c.get("user").id, category.projectId);
+    await requireWritable(project);
+    return c.json({ summary: await writeSummary(c.req.param("id")) });
+})
+    // A Kategorie a person sets on an item: `p:<page>`, `t:<table>`, `r:<row>`, `f:<file>`.
+    .put("/projects/:id/items/:key/categories/:categoryId", async (c) => {
+    const project = await ownedProject(c.get("user").id, c.req.param("id"));
+    await requireWritable(project);
+    const key = c.req.param("key");
+    const id = key.slice(2);
+    const ref = key[0] === "p"
+        ? { pageId: id }
+        : key[0] === "t"
+            ? { tableId: id }
+            : key[0] === "r"
+                ? { rowId: id }
+                : key[0] === "f"
+                    ? { fileId: id }
+                    : null;
+    if (!ref || key[1] !== ":") {
+        throw new ServiceError("invalid", "Unbekannter Eintrag.");
+    }
+    const { values } = z
+        .object({ values: z.array(z.union([z.string().max(300), z.number(), z.boolean()])).max(50) })
+        .parse(await c.req.json());
+    if (await setItemCategory(project.id, ref, c.req.param("categoryId"), values)) {
+        queueIndex(key[0] === "p" ? `P:${id}` : key);
+    }
+    return c.json({ ok: true });
 })
     // --- the space's tables and pages --------------------------------------------
     .get("/projects/:id/data", async (c) => c.json(await listSpaceData(c.get("user").id, c.req.param("id"))))
@@ -475,6 +605,7 @@ export const studio = new Hono()
         title: z.string().max(120),
         wizardId: z.string().nullish(),
         columns: z.unknown().optional(),
+        format: z.enum(["faq"]).nullish(),
     })
         .parse(await c.req.json());
     return c.json(await createTable(c.get("user").id, c.req.param("id"), body));
@@ -486,6 +617,8 @@ export const studio = new Hono()
         title: z.string().max(120).optional(),
         wizardId: z.string().nullish(),
         columns: z.unknown().optional(),
+        format: z.enum(["faq"]).nullish(),
+        review: z.null().optional(),
     })
         .parse(await c.req.json());
     await updateTable(c.get("user").id, c.req.param("id"), body);
@@ -515,6 +648,7 @@ export const studio = new Hono()
         .object({
         title: z.string().max(200),
         wizardId: z.string().nullish(),
+        parentId: z.string().nullish(),
         markdown: z.string().optional(),
     })
         .parse(await c.req.json());
@@ -526,11 +660,18 @@ export const studio = new Hono()
         .object({
         title: z.string().max(200).optional(),
         wizardId: z.string().nullish(),
+        parentId: z.string().nullish(),
         markdown: z.string().optional(),
+        review: z.null().optional(),
     })
         .parse(await c.req.json());
     await updatePage(c.get("user").id, c.req.param("id"), body);
     return c.json({ ok: true });
+})
+    .put("/pages/:id/order", async (c) => {
+    const { ids } = z.object({ ids: z.array(z.string()).max(5000) }).parse(await c.req.json());
+    await orderSubPages(c.get("user").id, c.req.param("id"), ids);
+    return c.json({ ok: true });
 })
     .delete("/pages/:id", async (c) => {
     await deletePage(c.get("user").id, c.req.param("id"));
@@ -639,7 +780,7 @@ export const studio = new Hono()
     // What a run of the draft is expected to cost, per step and in total.
     .get("/wizards/:id/estimate", async (c) => {
     const w = await ownedWizard(c.get("user").id, c.req.param("id"));
-    return c.json(await estimateRun(w.id, null, w.draft));
+    return c.json(await estimateRun(w.id, null, w.draft, await stepsWithoutModel(w.draft)));
 })
     // The models the draft needs that this runtime cannot serve, by class, with the steps that call them.
     .get("/wizards/:id/models", async (c) => {

package/apps/runtime/dist/services/cloud.js

@@ -112,14 +112,72 @@ async function spaceDataOf(projectId) {
         where: own(schema.spacePage),
         orderBy: [asc(schema.spacePage.id)],
     });
+    const categories = await db.query.spaceCategory.findMany({
+        where: and(eq(schema.spaceCategory.projectId, projectId), eq(schema.spaceCategory.proposed, false)),
+        orderBy: [asc(schema.spaceCategory.position), asc(schema.spaceCategory.id)],
+    });
+    const values = categories.length
+        ? await db.query.spaceCategoryValue.findMany({
+            where: inArray(schema.spaceCategoryValue.categoryId, categories.map((c) => c.id)),
+            orderBy: [asc(schema.spaceCategoryValue.position), asc(schema.spaceCategoryValue.id)],
+        })
+        : [];
+    const assignments = categories.length
+        ? await db.query.spaceItemCategory.findMany({
+            where: and(eq(schema.spaceItemCategory.projectId, projectId), isNull(schema.spaceItemCategory.fileId)),
+            orderBy: [asc(schema.spaceItemCategory.id)],
+        })
+        : [];
+    const tableIds = new Set(tables.map((t) => t.id));
+    const rowIds = new Set(rows.map((r) => r.id));
+    const pageIds = new Set(pages.map((p) => p.id));
     return {
         tables: tables.map((t) => ({
             id: t.id,
             title: t.title,
+            format: t.format,
+            originLabel: t.originLabel,
             columns: t.columns,
             rows: rows.filter((r) => r.tableId === t.id).map((r) => ({ id: r.id, cells: r.cells })),
         })),
-        pages: pages.map((p) => ({ id: p.id, title: p.title, markdown: p.markdown })),
+        pages: pages.map((p) => ({
+            id: p.id,
+            title: p.title,
+            markdown: p.markdown,
+            parentId: p.parentId,
+            position: p.position,
+            originLabel: p.originLabel,
+        })),
+        categories: categories.map((c) => ({
+            id: c.id,
+            name: c.name,
+            type: c.type,
+            unit: c.unit,
+            multiple: c.multiple,
+            ordered: c.ordered,
+            hint: c.hint,
+            tableId: c.tableId && tableIds.has(c.tableId) ? c.tableId : null,
+            columnId: c.tableId && tableIds.has(c.tableId) ? c.columnId : null,
+            position: c.position,
+            values: values
+                .filter((v) => v.categoryId === c.id)
+                .map((v) => ({ id: v.id, value: v.value, position: v.position, summary: v.summary })),
+        })),
+        // Only what goes along: a page, a table or a row of it.
+        assignments: assignments
+            .filter((a) => (a.pageId && pageIds.has(a.pageId)) ||
+            (a.tableId && tableIds.has(a.tableId)) ||
+            (a.rowId && rowIds.has(a.rowId)))
+            .map((a) => ({
+            categoryId: a.categoryId,
+            item: a.pageId ? `p:${a.pageId}` : a.tableId ? `t:${a.tableId}` : `r:${a.rowId}`,
+            valueId: a.valueId,
+            text: a.text,
+            num: a.num,
+            at: a.at,
+            bool: a.bool,
+            by: a.by,
+        })),
     };
 }
 /**