wizards 0.2.8 → 0.2.9

package/apps/runtime/dist/db/migrations/tenant/meta/_journal.json

@@ -43,6 +43,13 @@
       "when": 1791230045311,
       "tag": "0005_reflective_forgotten_one",
       "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "6",
+      "when": 1791283092075,
+      "tag": "0006_hard_war_machine",
+      "breakpoints": true
     }
   ]
 }

package/apps/runtime/dist/db/schema.js

@@ -198,18 +198,23 @@ export const projectFile = sqliteTable("project_file", {
     updatedAt: updatedAt(),
 }, (t) => [index("project_file_project").on(t.projectId, t.kind, t.position)]);
 /**
- * The document index: passages of a project's documents. Keywords live in the FTS5 table
- * `project_chunk_fts`, which triggers keep in step (see the migration); `embedding` is the
- * passage's vector as float32 bytes, compared with libSQL's `vector_distance_cos`.
+ * The document index: passages of a project's documents, and of the texts plugins put in
+ * (`server.index`). Keywords live in the FTS5 table `project_chunk_fts`, which triggers keep
+ * in step (see the migrations); `embedding` is the passage's vector as float32 bytes, compared
+ * with libSQL's `vector_distance_cos`.
  */
 export const projectChunk = sqliteTable("project_chunk", {
     id: integer("id").primaryKey({ autoIncrement: true }),
     projectId: text("project_id")
         .notNull()
         .references(() => project.id, { onDelete: "cascade" }),
-    fileId: text("file_id")
-        .notNull()
-        .references(() => projectFile.id, { onDelete: "cascade" }),
+    /** The document the passage is of; null for a plugin's text. */
+    fileId: text("file_id").references(() => projectFile.id, { onDelete: "cascade" }),
+    /** A plugin's text: the plugin, its key for the text, its title and where the studio shows it. */
+    plugin: text("plugin"),
+    ref: text("ref"),
+    title: text("title"),
+    link: text("link"),
     idx: integer("idx").notNull(),
     text: text("text").notNull(),
     embedding: blob("embedding", { mode: "buffer" }),
@@ -218,6 +223,7 @@ export const projectChunk = sqliteTable("project_chunk", {
 }, (t) => [
     index("project_chunk_project").on(t.projectId, t.model),
     index("project_chunk_file").on(t.fileId),
+    index("project_chunk_ref").on(t.projectId, t.plugin, t.ref),
 ]);
 // --- The wizard's store ------------------------------------------------------
 // What a wizard keeps between runs for one person. `holder` is that person: "u:<userId>" for a

package/apps/runtime/dist/engine/steps.js

@@ -7,6 +7,7 @@ import { generateImageMedia, generateSpeechMedia, generateVideoMedia, } from "..
 import { markMedia } from "../media/marking.js";
 import { attachTools, costOf, isHarnessVendor, textModel } from "../models.js";
 import { buildStepTools } from "../tools/index.js";
+import { spaceContextOf } from "../tools/plugin.js";
 import { personUploads } from "../tools/store.js";
 import { runWidgetStep } from "../widgets/step.js";
 import { prepareInputs } from "./prepare.js";
@@ -168,6 +169,8 @@ export async function runAgentStep(step, ctx) {
             `Today is ${today()}.`,
             brandBlock(ctx),
             documentsBlock(ctx),
+            // What the space's plugins hold for its wizards: a wiki, questions and answers.
+            ...(await spaceContextOf(ctx)).blocks,
             formatHint,
         ]
             .filter(Boolean)

package/apps/runtime/dist/env.js

@@ -218,6 +218,8 @@ export const env = {
          * alone. A runtime of a Manage-App never reloads: it would hit every tenant.
          */
         watch: !manageUrl && str("PLUGINS_WATCH", "1") === "1",
+        /** Plugins' jobs (`server.every`) run. Off (`PLUGIN_JOBS=0`) where another process runs them. */
+        jobs: str("PLUGIN_JOBS", "1") === "1",
     },
     limits: {
         visitorRunsPerHour: num("LIMIT_VISITOR_RUNS_PER_HOUR", 6),

package/apps/runtime/dist/index.js

@@ -6,6 +6,7 @@ import { resumeInterruptedRuns } from "./engine/runner.js";
 import { basePath, env } from "./env.js";
 import { managed } from "./manage.js";
 import { loadCatalog, loadLocalModels } from "./models.js";
+import { startJobs } from "./plugins/jobs.js";
 import { loadPlugins } from "./plugins/loader.js";
 import { closeBrowser } from "./render/chromium.js";
 import { clearRunning, writeRunning } from "./running.js";
@@ -17,6 +18,7 @@ import { onRestart } from "./update.js";
 await migrateControlDb();
 // Before any tenant database opens: each gets the plugins' own tables as it does.
 await loadPlugins();
+startJobs();
 if (managed) {
     // Every tenant database is brought to this release's schema; a new one migrates when first opened.
     void migrateAllTenants().then(({ migrated, failed }) => {

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

@@ -385,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",

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);

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

@@ -1,10 +1,13 @@
 import { embedMany } from "ai";
-import { eq, inArray, sql } from "drizzle-orm";
+import { and, eq, inArray, sql } from "drizzle-orm";
 import { db, schema } from "../db/client.js";
 import { parseDocument } from "../documents/parse.js";
 import { createSearchChunks } from "../engenty/search-index/chunks.js";
 import { getBlob, putBlob } from "../files/blobs.js";
 import { embeddingModel } from "../models.js";
+import { pluginIdsOf } from "../plugins/registry.js";
+import { currentTenant } from "../tenants/tenant.js";
+import { ServiceError } from "./errors.js";
 const CHUNK = { mode: "paragraph", max_chunk_length: 1200, overlap: 120 };
 /** Passages of one document; a longer one keeps its start. */
 const MAX_CHUNKS = 2000;
@@ -53,6 +56,51 @@ export async function indexDocument(file, data) {
         text,
     };
 }
+/** Puts a plugin's text into the space's index, in the place of what its key held. */
+export async function putIndexEntry(plugin, entry) {
+    const space = await db.query.project.findFirst({ where: eq(schema.project.id, entry.space) });
+    if (!space) {
+        throw new ServiceError("not_found", `There is no space "${entry.space}".`);
+    }
+    const text = `${entry.title.trim()}\n\n${entry.text.trim()}`;
+    const chunks = createSearchChunks({ doc_id: `${plugin}:${entry.key}`, text, ...CHUNK }).slice(0, MAX_CHUNKS);
+    const embedded = await embed(chunks.map((c) => c.text)).catch((err) => {
+        console.error("[project-index] embedding failed", err);
+        return null;
+    });
+    await removeIndexEntries(plugin, entry.space, entry.key);
+    for (let i = 0; i < chunks.length; i += 100) {
+        await db.insert(schema.projectChunk).values(chunks.slice(i, i + 100).map((c, j) => ({
+            projectId: entry.space,
+            plugin,
+            ref: entry.key,
+            title: entry.title.trim().slice(0, 300),
+            link: entry.link ?? null,
+            idx: c.chunk_index,
+            text: c.text,
+            embedding: embedded ? vectorBytes(embedded.vectors[i + j]) : null,
+            model: embedded?.model ?? null,
+        })));
+    }
+}
+/** Takes a plugin's text out of the space's index; without a key, all of the plugin's texts. */
+export async function removeIndexEntries(plugin, space, key) {
+    await db
+        .delete(schema.projectChunk)
+        .where(and(eq(schema.projectChunk.projectId, space), eq(schema.projectChunk.plugin, plugin), key === undefined ? undefined : eq(schema.projectChunk.ref, key)));
+}
+/** Whether a plugin the tenant has put a text into the space's index. */
+export async function hasIndexEntries(projectId) {
+    const plugins = [...(await pluginIdsOf(currentTenant()))];
+    if (!plugins.length) {
+        return false;
+    }
+    const found = await db.query.projectChunk.findFirst({
+        columns: { id: true },
+        where: and(eq(schema.projectChunk.projectId, projectId), inArray(schema.projectChunk.plugin, plugins)),
+    });
+    return Boolean(found);
+}
 export async function documentText(file) {
     return file.textHash ? (await getBlob(file.textHash)).toString("utf8") : "";
 }
@@ -64,23 +112,32 @@ function keywordQuery(query) {
         .slice(0, 16);
     return words.length ? words.map((w) => `"${w}"*`).join(" OR ") : null;
 }
-/** The passages of the project's documents that fit a question best. */
+/** A passage of a document, or of a plugin's text while the tenant has that plugin. */
+function searchable(plugins, alias = "") {
+    const column = sql.raw(`${alias}plugin`);
+    return plugins.length
+        ? sql `(${column} IS NULL OR ${column} IN (${sql.join(plugins.map((p) => sql `${p}`), sql `, `)}))`
+        : sql `${column} IS NULL`;
+}
+/** The passages of the project's documents, and of the texts its plugins put in, that fit a question best. */
 export async function searchProject(projectId, query, limit = 6) {
+    const plugins = [...(await pluginIdsOf(currentTenant()))];
     const lists = [];
     const keywords = keywordQuery(query);
     if (keywords) {
         lists.push(await db.all(sql `
-        SELECT c.id, c.file_id, c.idx, c.text
+        SELECT c.id, c.file_id, c.plugin, c.ref, c.title, c.link, c.idx, c.text
         FROM project_chunk_fts f JOIN project_chunk c ON c.id = f.rowid
         WHERE project_chunk_fts MATCH ${keywords} AND c.project_id = ${projectId}
+          AND ${searchable(plugins, "c.")}
         ORDER BY bm25(project_chunk_fts) LIMIT 24`));
     }
     const embedded = await embed([query]).catch(() => null);
     if (embedded) {
         lists.push(await db.all(sql `
-        SELECT id, file_id, idx, text
+        SELECT id, file_id, plugin, ref, title, link, idx, text
         FROM project_chunk
-        WHERE project_id = ${projectId} AND model = ${embedded.model}
+        WHERE project_id = ${projectId} AND model = ${embedded.model} AND ${searchable(plugins)}
         ORDER BY vector_distance_cos(embedding, ${vectorBytes(embedded.vectors[0])}) LIMIT 24`));
     }
     // Reciprocal rank fusion: a passage both lists rank high comes first.
@@ -96,12 +153,15 @@ export async function searchProject(projectId, query, limit = 6) {
     if (!top.length) {
         return [];
     }
-    const files = await db.query.projectFile.findMany({
-        where: inArray(schema.projectFile.id, [...new Set(top.map((t) => t.hit.file_id))]),
-    });
+    const fileIds = [...new Set(top.map((t) => t.hit.file_id).filter((id) => id !== null))];
+    const files = fileIds.length
+        ? await db.query.projectFile.findMany({ where: inArray(schema.projectFile.id, fileIds) })
+        : [];
     return top.map(({ hit, score }) => ({
         fileId: hit.file_id,
-        name: files.find((f) => f.id === hit.file_id)?.name ?? "",
+        plugin: hit.plugin,
+        name: hit.file_id ? (files.find((f) => f.id === hit.file_id)?.name ?? "") : (hit.title ?? ""),
+        link: hit.link,
         index: hit.idx,
         text: hit.text,
         score: Math.round(score * 10_000) / 10_000,