@manta-eu/horns-server 0.1.0

package/dist/studio-routes.js

@@ -0,0 +1,382 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { isPresent } from "@manta-eu/lib/present";
+import { hornSchema, isRealm } from "@manta-eu/horns";
+import { acceptedSpecs, assembleStudioMessages, createDryRun, evaluateProposal, formatFailures, hornPatchOpSchema, buildUsefulContext, builtInSkills, datastoreFacts, evaluateShapeViewOnZoo, selectSkills, runShapeCoverage, runShapeViewTurn, adviseOnHorn, runStudioTurn, sampleShapeFillRates, studioReadHandlers, studioSystemPrompt, studioWriteHandlers, } from "@manta-eu/horns/studio";
+import { shapeLinks, shapeViewSpecSchema, termNotes } from "@manta-eu/horns/shapes";
+import { mantaReactCatalog } from "@manta-eu/horns-kit/catalog";
+import { shapeViewSpecs } from "@manta-eu/horns-kit/shape-views";
+import { sameOriginDeniedResponse, signedOutMessage } from "./agents-proxy.js";
+import { datastoreAccessFor, datastoreAccessUnavailableMessage, datastoreNotGrantedMessage, forgetDatastoreAccess, grantsDatastore, } from "./datastore-access.js";
+import { parseBody } from "./authorize.js";
+import { stageRule } from "./manta-rules.js";
+import { criticModelFromEnv, studioModelFromEnv } from "./llm.js";
+import { requestSession } from "./dev-session.js";
+import { ndjsonResponse } from "./ndjson.js";
+import { isSignedIn } from "./session.js";
+import { agentsSparqlSelect } from "./sparql-select.js";
+const noStore = { "cache-control": "no-store" };
+/**
+ * How many model rounds one request may take.
+ *
+ * Twenty-four ran out on real work — fifteen queries and three repairs and the turn is over, which costs
+ * the person a whole round trip to say "continue". dyad allows a hundred tool-call steps and keeps only the
+ * last few chat turns in context; this is the same trade, sized for a worker request rather than a desktop.
+ */
+const turnStepLimit = 48;
+/**
+ * How much of the conversation goes back to the model.
+ *
+ * The draft itself is in `<useful-context>`, so the history is there for intent, not for state — and every
+ * message of it is context the turn cannot spend on work. dyad keeps three turns by default; this keeps six,
+ * because our messages are short and the earlier ones carry what someone wants the Horn to look like.
+ */
+export const maxHistoryTurns = 6;
+// A picture of a Horn at the capture width is tens of kilobytes; a data URL of more than this is not one.
+export const maxReviewImageChars = 6 * 1024 * 1024;
+const reviewRequestSchema = z.object({
+    /** The Horn as the browser drew it, as a PNG data URL. */
+    image: z
+        .string()
+        .regex(/^data:image\/png;base64,/)
+        .max(maxReviewImageChars),
+    /** What the person asked for, so the critic can say the answer does not answer it. */
+    asked: z.string().trim().min(1).max(2000).optional(),
+});
+const messagesSchema = z
+    .array(z.object({ role: z.enum(["user", "assistant"]), content: z.string().min(1).max(4000) }))
+    .min(1)
+    .max(40);
+// A shape view is a card and the fields it reads; the shape and the class are not the model's to change.
+const viewTurnRequestSchema = z.object({
+    spec: shapeViewSpecSchema,
+    messages: messagesSchema,
+});
+const turnRequestSchema = z.object({
+    horn: hornSchema,
+    messages: messagesSchema,
+});
+// One shape is a minute or two of watching. Three is the most anyone waits at a page before it stops being
+// live and becomes a job, and a job is what the script is for.
+const coverageRequestSchema = z.object({ limit: z.number().int().min(1).max(3).optional() });
+// An edit a person made themselves — renaming a view, taking one out — as the same ops a turn proposes.
+const editRequestSchema = z.object({
+    horn: hornSchema,
+    ops: z.array(hornPatchOpSchema).min(1).max(20),
+});
+/**
+ * One turn of talking to a Horn. The draft arrives in the body and comes back changed — nothing is stored
+ * here: saving is the save route's job, with its own lock check and its own authorization.
+ *
+ * Prior turns travel as their text alone. Their tool calls described a draft the user has since changed, and
+ * re-sending them would ask the model to reason from a Horn that no longer exists; useful-context carries the
+ * one that does.
+ */
+export function studioRoutes(deps) {
+    const routes = new Hono();
+    /**
+     * Same origin, a session, and a datastore this session was granted. Both lanes ask the same question, and a
+     * second copy of it is a second place to get it wrong.
+     */
+    const context = async (c) => {
+        const denied = sameOriginDeniedResponse(c.req.raw);
+        if (denied)
+            return { ok: false, response: denied };
+        const session = requestSession(c.req.raw, c.env);
+        if (!isPresent(session) || !isSignedIn(session)) {
+            return { ok: false, response: Response.json({ error: signedOutMessage }, { status: 401 }) };
+        }
+        const configured = c.env.VITE_KEYCLOAK_REALM;
+        if (!isPresent(configured) || !isRealm(configured)) {
+            return {
+                ok: false,
+                response: Response.json({ error: "This deployment has no realm configured." }, { status: 500 }),
+            };
+        }
+        const datastoreId = c.req.param("datastoreId");
+        const resolved = await datastoreAccessFor(c.env, session);
+        if (!resolved.ok) {
+            return {
+                ok: false,
+                response: Response.json({ error: resolved.reason === "unauthenticated" ? signedOutMessage : datastoreAccessUnavailableMessage }, { status: resolved.reason === "unauthenticated" ? 401 : 502 }),
+            };
+        }
+        if (!grantsDatastore(resolved.access, datastoreId)) {
+            forgetDatastoreAccess(session);
+            return { ok: false, response: Response.json({ error: datastoreNotGrantedMessage }, { status: 403 }) };
+        }
+        return { ok: true, session, realm: configured, datastoreId };
+    };
+    routes.post("/api/d/:datastoreId/studio", async (c) => {
+        const allowed = await context(c);
+        if (!allowed.ok)
+            return allowed.response;
+        const { session, realm, datastoreId } = allowed;
+        const parsed = await parseBody(c.req.raw, turnRequestSchema);
+        if (!parsed.ok)
+            return parsed.response;
+        const { horn, messages } = parsed.data;
+        if (horn.datastoreId !== datastoreId) {
+            return c.json({ error: `This Horn belongs to the "${horn.datastoreId}" datastore.` }, 400);
+        }
+        const model = (deps.model ?? studioModelFromEnv)(c.env, { feature: "horns-studio", datastoreId });
+        if (!model.ok)
+            return c.json({ error: model.reason }, 503);
+        const select = agentsSparqlSelect({
+            requestUrl: c.req.raw.url,
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            session,
+            datastoreId,
+        });
+        const typed = realm;
+        const shapes = deps.shapes(typed);
+        const [latest, ...earlier] = [...messages].reverse();
+        // Newest first here, so this keeps the most recent exchanges and drops the oldest.
+        const carried = earlier.slice(0, maxHistoryTurns * 2);
+        const asked = latest?.content ?? "";
+        // Streamed like a shape view's turn: each event as the loop records it, then the result. A turn that
+        // looks at the data before it changes anything is a minute of work, and that minute should be visible.
+        return ndjsonResponse(async (emit) => {
+            emit({ type: "progress", event: { type: "reading" } });
+            // A class's shape is what a platform sends; what Manta's rules work out about it is on nothing's property
+            // list, so the turn is given it up front rather than left to discover that half of the graph exists.
+            const useful = buildUsefulContext({
+                realm: typed,
+                prompt: asked,
+                horn,
+                ...(await datastoreFacts({ realm: typed, select, shapes, prompt: asked, signal: c.req.raw.signal })),
+                library: [],
+                catalog: mantaReactCatalog,
+                skills: selectSkills(asked, builtInSkills),
+            });
+            const turn = await runStudioTurn({
+                model: model.model,
+                mode: "build",
+                draft: horn,
+                messages: assembleStudioMessages({
+                    system: studioSystemPrompt({ mode: "build", realm: typed }),
+                    history: [...carried].reverse(),
+                    usefulContext: useful.text,
+                    userMessage: asked,
+                }),
+                handlers: {
+                    ...studioReadHandlers({
+                        realm: typed,
+                        select,
+                        shapes,
+                        views: shapeViewSpecs,
+                        model: model.model,
+                        // The investigation is a loop of its own; without this it is one line that takes a minute.
+                        onEvent: (event) => emit({ type: "progress", event }),
+                    }),
+                    ...studioWriteHandlers({
+                        realm: typed,
+                        select,
+                        catalog: mantaReactCatalog,
+                        lookup: () => undefined,
+                        // As the viewer: staging a rule is attributed to a person, and agents refuses it otherwise.
+                        stageRule: (rule) => stageRule({ agentsUrl: c.env.MANTA_AGENTS_URL, session, datastoreId }, rule),
+                    }),
+                },
+                maxSteps: turnStepLimit,
+                signal: c.req.raw.signal,
+                onEvent: (event) => emit({ type: "progress", event }),
+            });
+            emit({ type: "result", horn: turn.draft, reply: turn.reply, status: turn.status, steps: turn.steps });
+        }, noStore);
+    });
+    /**
+     * One turn of talking to a shape's view. The same lane as a Horn's, over a smaller thing: a view is a card
+     * and the fields it reads, and its gate is the zoo — the gate the coverage runs already judge by, so a view
+     * changed here is held to what a view generated here is held to.
+     */
+    /**
+     * A change the person made with their own hands. It goes through the gate a model's patch goes through —
+     * applied by id with a fingerprint, validated, locked and dry-run — because a Horn that cannot be drawn is
+     * no better for having been broken by hand. Nothing is stored: the draft goes back to the Studio, which
+     * saves when the person says so.
+     */
+    /**
+     * A second model looks at what the Studio drew and says what is wrong with it.
+     *
+     * The picture comes from the browser, because the browser is the only thing that can draw a Horn: every
+     * view is written source composing the design system. Advice, never a verdict — it is shown to the person
+     * and offered back to the Studio, and it never blocks a save.
+     */
+    routes.post("/api/d/:datastoreId/horns/review", async (c) => {
+        const allowed = await context(c);
+        if (!allowed.ok)
+            return allowed.response;
+        const { datastoreId } = allowed;
+        const parsed = await parseBody(c.req.raw, reviewRequestSchema);
+        if (!parsed.ok)
+            return parsed.response;
+        // Never the Studio's own model as a fallback, unlike the shape critic: that one can read a card as text,
+        // and this one has only a picture. Qwen would be shown an image it cannot see and would answer about
+        // nothing. Unconfigured means no reviewer, and the caller is told why.
+        const critic = (deps.criticModel ?? criticModelFromEnv)(c.env, { feature: "horn-critic", datastoreId });
+        if (!critic.ok)
+            return c.json({ error: critic.reason }, 503);
+        const advice = await adviseOnHorn({
+            model: critic.model,
+            image: parsed.data.image,
+            ...(parsed.data.asked === undefined ? {} : { asked: parsed.data.asked }),
+            signal: c.req.raw.signal,
+        });
+        return c.json({ advice }, 200, noStore);
+    });
+    routes.post("/api/d/:datastoreId/horns/edit", async (c) => {
+        const allowed = await context(c);
+        if (!allowed.ok)
+            return allowed.response;
+        const { session, realm, datastoreId } = allowed;
+        const parsed = await parseBody(c.req.raw, editRequestSchema);
+        if (!parsed.ok)
+            return parsed.response;
+        const { horn, ops } = parsed.data;
+        if (horn.datastoreId !== datastoreId) {
+            return c.json({ error: `This Horn belongs to the "${horn.datastoreId}" datastore.` }, 400);
+        }
+        const select = agentsSparqlSelect({
+            requestUrl: c.req.raw.url,
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            session,
+            datastoreId,
+        });
+        const result = await evaluateProposal(horn, ops, {
+            realm,
+            catalog: mantaReactCatalog,
+            lookup: () => undefined,
+            dryRun: createDryRun({ realm, select }),
+        });
+        if (!result.accepted) {
+            return c.json({ error: `That change did not hold up:\n${formatFailures(result.failures)}` }, 422);
+        }
+        return c.json({ horn: result.horn }, 200, noStore);
+    });
+    /**
+     * The coverage run, watched while it happens. The script is the durable one — it resumes, keeps transcripts
+     * and writes the kit; this stores nothing, because a run nobody is watching has no reason to go through a
+     * browser. What it designs comes back in the result, and saving stays where reviewing is: the zoo.
+     */
+    routes.post("/api/d/:datastoreId/shapes/cover", async (c) => {
+        const allowed = await context(c);
+        if (!allowed.ok)
+            return allowed.response;
+        const { session, realm, datastoreId } = allowed;
+        const body = await c.req.json().catch(() => undefined);
+        const parsed = coverageRequestSchema.safeParse(body ?? {});
+        if (!parsed.success)
+            return c.json({ error: "The request is invalid — limit must be between 1 and 3." }, 400);
+        const model = (deps.model ?? studioModelFromEnv)(c.env, { feature: "shape-coverage", datastoreId });
+        if (!model.ok)
+            return c.json({ error: model.reason }, 503);
+        // Optional: with no critic route it is the Studio's own model. Either way it reads the card as text —
+        // a shape's card is drawn by a browser now, and a coverage run has none.
+        const critic = deps.criticModel?.(c.env, { feature: "shape-critic", datastoreId });
+        const select = agentsSparqlSelect({
+            requestUrl: c.req.raw.url,
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            session,
+            datastoreId,
+        });
+        return ndjsonResponse(async (emit) => {
+            const state = await runShapeCoverage({
+                model: model.model,
+                select,
+                realm,
+                datastoreId,
+                shapes: deps.shapes(realm),
+                views: shapeViewSpecs,
+                // Watched, not resumed: the run starts from the kit's views every time and remembers nothing after it.
+                store: { load: async () => undefined, save: async () => undefined, saveTranscript: async () => undefined },
+                limit: parsed.data.limit ?? 1,
+                signal: c.req.raw.signal,
+                // Somebody is watching this one, so the critic's second opinion is worth the extra call.
+                advise: true,
+                ...(critic?.ok ? { criticModel: critic.model } : {}),
+                onTurnProgress: (progress) => emit({ type: "progress", ...progress }),
+                onProgress: ({ schema, result, index, total }) => emit({
+                    type: "shape",
+                    schema,
+                    index,
+                    total,
+                    status: result.status,
+                    ...(result.status === "accepted"
+                        ? { spec: result.spec, rounds: result.rounds, advice: result.advice ?? [] }
+                        : {}),
+                    ...(result.status === "gave-up" ? { problems: result.problems } : {}),
+                    ...(result.status === "failed" ? { error: result.error } : {}),
+                }),
+            });
+            const results = Object.values(state.shapes);
+            emit({
+                type: "result",
+                accepted: acceptedSpecs(state).map((spec) => spec.schema),
+                gaveUp: results.filter((result) => result.status === "gave-up").length,
+                noData: results.filter((result) => result.status === "no-data").length,
+                failed: results.filter((result) => result.status === "failed").length,
+            });
+        }, noStore);
+    });
+    routes.post("/api/d/:datastoreId/shape-views/:schema/studio", async (c) => {
+        const allowed = await context(c);
+        if (!allowed.ok)
+            return allowed.response;
+        const { session, realm, datastoreId } = allowed;
+        const parsed = await parseBody(c.req.raw, viewTurnRequestSchema);
+        if (!parsed.ok)
+            return parsed.response;
+        const schema = c.req.param("schema");
+        const shapes = deps.shapes(realm);
+        const shape = shapes.find((candidate) => candidate.schema === schema);
+        if (!shape)
+            return c.json({ error: `There is no shape called "${schema}" in this realm.` }, 404);
+        if (parsed.data.spec.schema !== schema) {
+            return c.json({ error: `That view is for ${parsed.data.spec.schema}, not ${schema}.` }, 400);
+        }
+        const model = (deps.model ?? studioModelFromEnv)(c.env, { feature: "horns-shape-view", datastoreId });
+        if (!model.ok)
+            return c.json({ error: model.reason }, 503);
+        const select = agentsSparqlSelect({
+            requestUrl: c.req.raw.url,
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            session,
+            datastoreId,
+        });
+        // A turn is up to three model rounds; see `ndjsonResponse` for why it streams.
+        return ndjsonResponse(async (emit) => {
+            const { sampled, fillRates } = await sampleShapeFillRates(shape, select, undefined, c.req.raw.signal);
+            const [latest, ...earlier] = [...parsed.data.messages].reverse();
+            const turn = await runShapeViewTurn({
+                model: model.model,
+                shape,
+                realm,
+                draft: parsed.data.spec,
+                request: latest?.content ?? "",
+                history: [...earlier].reverse(),
+                fillRates,
+                sampled,
+                links: await shapeLinks({ shape, shapes: [...shapes], realm, select, signal: c.req.raw.signal }),
+                notes: await termNotes({
+                    realm,
+                    terms: [shape.classIri, ...shape.properties.map((property) => property.path)],
+                    select,
+                    signal: c.req.raw.signal,
+                }),
+                evaluate: evaluateShapeViewOnZoo({ realm, datastoreId, select }),
+                signal: c.req.raw.signal,
+                onProgress: (progress) => emit({ type: "progress", ...progress }),
+            });
+            const reply = turn.messages.filter((message) => message.role === "assistant").at(-1)?.content ?? "";
+            emit({
+                type: "result",
+                reply,
+                ...(turn.status === "accepted"
+                    ? { spec: turn.spec, status: turn.status, rounds: turn.rounds, repairs: turn.repairs, problems: [] }
+                    : { spec: parsed.data.spec, status: turn.status, rounds: turn.rounds, repairs: [], problems: turn.problems }),
+            });
+        }, noStore);
+    });
+    return routes;
+}

package/dist/worker.d.ts

@@ -0,0 +1,14 @@
+import { Hono } from "hono";
+import type { Env } from "./env.ts";
+import { type StudioRoutesDeps } from "./studio-routes.ts";
+export type { Env };
+export type HornsWorkerOptions = Pick<StudioRoutesDeps<Env>, "shapes"> & Partial<Pick<StudioRoutesDeps<Env>, "criticModel">>;
+/**
+ * The Horns worker as a Hono app. `shapes` is the host's: the catalog describes a realm's data model, so
+ * Horns takes it rather than shipping one.
+ */
+export declare function createHornsApp({ shapes, criticModel }: HornsWorkerOptions): Hono<{
+    Bindings: Env;
+}, import("hono/types").BlankSchema, "/">;
+/** The same app behind Sentry, ready to be a Worker's default export. */
+export declare function createHornsWorker(options: HornsWorkerOptions): ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>;

package/dist/worker.js

@@ -0,0 +1,169 @@
+import { Hono } from "hono";
+import { captureException, withSentry } from "@sentry/cloudflare";
+import { isPresent } from "@manta-eu/lib/present";
+import { proxyToMantaAgents, sameOriginDeniedResponse, signedOutMessage } from "./agents-proxy.js";
+import { authUnavailableResponse, callbackPath, localSignOutResponse, loginPath, loginRequestWithMarker, logoutPath, logoutResponseReturningTo, } from "./auth-routes.js";
+import { datastoreAccessFor, datastoreAccessUnavailableMessage, datastoreNotGrantedMessage, forgetDatastoreAccess, grantsDatastore, } from "./datastore-access.js";
+import { hornRoutes } from "./horn-routes.js";
+import { actionPlanRoutes } from "./action-plan-routes.js";
+import { studioRoutes } from "./studio-routes.js";
+import { criticModelFromEnv } from "./llm.js";
+import { requestSession } from "./dev-session.js";
+import { asJsonRequest, followedLink, noPageToOpen, signInFirst } from "./entity-links.js";
+import { isSignedIn } from "./session.js";
+import { sentryOptionsForDeploy } from "./sentry.js";
+/**
+ * The Horns worker as a Hono app. `shapes` is the host's: the catalog describes a realm's data model, so
+ * Horns takes it rather than shipping one.
+ */
+export function createHornsApp({ shapes, criticModel = criticModelFromEnv }) {
+    const app = new Hono();
+    app.use("*", async (c, next) => {
+        if (import.meta.env.DEV)
+            return next();
+        const expected = c.env.SITE_PASSWORD;
+        const header = c.req.header("authorization");
+        if (expected && header?.startsWith("Basic ")) {
+            try {
+                const decoded = atob(header.slice(6));
+                const password = decoded.slice(decoded.indexOf(":") + 1);
+                if (password === expected)
+                    return next();
+            }
+            catch {
+                /* a malformed header is just a failed attempt */
+            }
+        }
+        return c.text("Authentication required.", 401, {
+            "WWW-Authenticate": 'Basic realm="Manta Horns", charset="UTF-8"',
+        });
+    });
+    function userSession(c) {
+        return requestSession(c.req.raw, c.env);
+    }
+    function proxyRequest(c, request) {
+        const session = userSession(c);
+        return proxyToMantaAgents({
+            request,
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            ...(isPresent(session) ? { session } : {}),
+        });
+    }
+    function agentsProxy(c) {
+        return proxyRequest(c, c.req.raw);
+    }
+    async function recovering(run, request, recover) {
+        try {
+            return await run();
+        }
+        catch (caught) {
+            captureException(caught, { tags: { path: new URL(request.url).pathname, method: request.method } });
+            return recover(request);
+        }
+    }
+    app.get(loginPath, (c) => recovering(() => proxyRequest(c, loginRequestWithMarker(c.req.raw)), c.req.raw, authUnavailableResponse));
+    app.get(callbackPath, (c) => recovering(() => agentsProxy(c), c.req.raw, authUnavailableResponse));
+    app.on(["GET", "POST"], logoutPath, (c) => recovering(async () => {
+        const response = await agentsProxy(c);
+        // 5xx: agents never dropped our cookies — sign out locally instead.
+        if (response.status >= 500)
+            return localSignOutResponse(c.req.raw);
+        return logoutResponseReturningTo(response, c.req.raw);
+    }, c.req.raw, localSignOutResponse));
+    const signedOutLoginStatus = { valid: false, canSwitchDatastore: false, allowedModels: [] };
+    app.get("/api/login", async (c) => {
+        const denied = sameOriginDeniedResponse(c.req.raw);
+        if (denied)
+            return denied;
+        if (!isSignedIn(userSession(c)))
+            return c.json(signedOutLoginStatus);
+        const response = await agentsProxy(c);
+        return response.status === 401 ? c.json(signedOutLoginStatus) : response;
+    });
+    app.get("/api/data/context", async (c) => {
+        const denied = sameOriginDeniedResponse(c.req.raw);
+        if (denied)
+            return denied;
+        if (!isSignedIn(userSession(c)))
+            return c.json({ error: signedOutMessage }, 401);
+        const response = await agentsProxy(c);
+        return response.status === 401 ? c.json({ error: signedOutMessage }, 401) : response;
+    });
+    // The memoised grants name the datastore the caller just left, so they go when they leave it.
+    app.post("/api/switch-datastore", async (c) => {
+        const response = await agentsProxy(c);
+        const session = userSession(c);
+        if (response.ok && isPresent(session))
+            forgetDatastoreAccess(session);
+        return response;
+    });
+    // The worker's own trust header is never the caller's to set, on any path.
+    function withoutTrustHeaders(request) {
+        const headers = new Headers(request.headers);
+        headers.delete("x-sparql-update-key");
+        const init = { method: request.method, headers, body: request.body };
+        Object.assign(init, { duplex: "half" });
+        return new Request(request.url, init);
+    }
+    // Agents answers a read for a datastore the caller lacks from the caller's own datastore instead of
+    // refusing, so the path means what it says only if the session's grants are what decided it.
+    app.post("/d/:datastoreId/sparql", async (c) => {
+        const denied = sameOriginDeniedResponse(c.req.raw);
+        if (denied)
+            return denied;
+        const session = userSession(c);
+        if (!isPresent(session) || !isSignedIn(session))
+            return c.json({ error: signedOutMessage }, 401);
+        const resolved = await datastoreAccessFor(c.env, session);
+        if (!resolved.ok) {
+            if (resolved.reason === "unauthenticated")
+                return c.json({ error: signedOutMessage }, 401);
+            return c.json({ error: datastoreAccessUnavailableMessage }, 502);
+        }
+        if (!grantsDatastore(resolved.access, c.req.param("datastoreId"))) {
+            forgetDatastoreAccess(session);
+            return c.json({ error: datastoreNotGrantedMessage }, 403);
+        }
+        return proxyRequest(c, withoutTrustHeaders(c.req.raw));
+    });
+    // A link from a Horn's row to the thing it shows, opened as the viewer in a new tab.
+    app.get("/d/:datastoreId/redirect", async (c) => {
+        const datastoreId = c.req.param("datastoreId");
+        const session = userSession(c);
+        if (!isPresent(session) || !isSignedIn(session))
+            return signInFirst(c.req.raw);
+        const resolved = await datastoreAccessFor(c.env, session);
+        if (!resolved.ok) {
+            return resolved.reason === "unauthenticated" ? signInFirst(c.req.raw) : noPageToOpen(datastoreId, 502);
+        }
+        // Refused the way agents refuses a record: as not found, so the link cannot probe another datastore.
+        if (!grantsDatastore(resolved.access, datastoreId)) {
+            forgetDatastoreAccess(session);
+            return noPageToOpen(datastoreId, 404);
+        }
+        const response = await proxyRequest(c, asJsonRequest(c.req.raw));
+        if (response.status === 401)
+            return signInFirst(c.req.raw);
+        return (followedLink(response, c.env.MANTA_AGENTS_URL ?? "") ??
+            noPageToOpen(datastoreId, response.status === 400 || response.status === 404 ? 404 : 502));
+    });
+    app.route("/", hornRoutes());
+    app.route("/", actionPlanRoutes());
+    app.route("/", studioRoutes({ shapes, criticModel }));
+    app.all("*", (c) => c.env.ASSETS.fetch(c.req.raw));
+    app.onError((err, c) => {
+        captureException(err, { tags: { path: c.req.routePath, method: c.req.method } });
+        if (import.meta.env.DEV) {
+            console.error(`[horns] ${c.req.method} ${new URL(c.req.raw.url).pathname} failed:`, err);
+        }
+        return c.json({ error: "Internal Server Error" }, 500);
+    });
+    return app;
+}
+/** The same app behind Sentry, ready to be a Worker's default export. */
+export function createHornsWorker(options) {
+    const app = createHornsApp(options);
+    return withSentry(sentryOptionsForDeploy, {
+        fetch: (request, env, ctx) => app.fetch(request, env, ctx),
+    });
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@manta-eu/horns-server",
+  "version": "0.1.0",
+  "description": "The Manta Horns worker as a library: Hono routes a Cloudflare host mounts on its own app.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/manta-eu/manta-horns.git",
+    "directory": "packages/horns-server"
+  },
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "default": "./dist/worker.js"
+    },
+    "./shared": {
+      "types": "./dist/shared.d.ts",
+      "default": "./dist/shared.js"
+    },
+    "./llm": {
+      "types": "./dist/llm.d.ts",
+      "default": "./dist/llm.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "dependencies": {
+    "@manta-eu/lib": "0.1.4",
+    "@sentry/cloudflare": "^10.70.0",
+    "@sentry/core": "^10.70.0",
+    "hono": "^4.9.8",
+    "ldkit": "2.8.0",
+    "sparqljs": "^3.7.4",
+    "zod": "^4.5.4",
+    "@manta-eu/horns": "0.1.0",
+    "@manta-eu/horns-kit": "0.1.0"
+  },
+  "devDependencies": {
+    "@cloudflare/vite-plugin": "1.47.0",
+    "@types/sparqljs": "^3.1.12",
+    "rimraf": "^6.1.3",
+    "typescript": "^5.9.0",
+    "vite": "^7.3.6",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "types": "tsc --noEmit && tsc -p tsconfig.build.json --noEmit",
+    "test": "vitest run",
+    "build": "rimraf dist && tsc -p tsconfig.build.json"
+  }
+}