@manta-eu/horns-server 0.2.0 → 0.2.2

package/dist/horn-routes.js

@@ -484,6 +484,83 @@ export function hornRoutes(deps = {}) {
      * Two segments because one would not be safe: `about` is a legal slug, so `/horns/about` is a Horn
      * somebody may have saved, and `/horns/:slug` would answer for it either way.
      */
+    // Three fit beside a thing without pushing it off the screen; ten is where the reading cost stops being
+    // one query and starts being a page of them.
+    const defaultAboutLimit = 3;
+    const maxAboutLimit = 10;
+    /**
+     * Every Horn about a thing, for a host that has room for more than one.
+     *
+     * The singular route answers with one and counts the rest, which is what a panel beside a plan wants.
+     * A host showing a thing's whole story wants them all: `?limit=` caps how many come back whole, and
+     * `total` says how many there are. Nothing kept falls back the same way the singular route does, so an
+     * IRI nobody has made a Horn for still draws.
+     */
+    routes.get("/api/d/:datastoreId/horns/by/about/list", async (c) => {
+        const datastoreId = c.req.param("datastoreId");
+        const authorized = await authorize(c.req.raw, c.env, datastoreId);
+        if (!authorized.ok)
+            return authorized.response;
+        const realm = c.env.VITE_KEYCLOAK_REALM;
+        if (!isPresent(realm) || !isRealm(realm))
+            return refuse(500, "This deployment has no realm configured.").response;
+        const about = c.req.query("iri");
+        if (!isPresent(about))
+            return refuse(400, "Ask with ?iri=<the thing's IRI>.").response;
+        if (!isAbsoluteIri(about))
+            return refuse(400, `"${about}" is not an IRI.`).response;
+        const asked = Number(c.req.query("limit") ?? defaultAboutLimit);
+        if (!Number.isInteger(asked) || asked < 1 || asked > maxAboutLimit) {
+            return refuse(400, `limit is a whole number from 1 to ${maxAboutLimit}.`).response;
+        }
+        const select = agentsSparqlSelect({
+            agentsUrl: c.env.MANTA_AGENTS_URL,
+            upstream: c.env.UPSTREAM,
+            session: authorized.session,
+            datastoreId,
+        });
+        try {
+            const found = await select(hornsAboutQuery(realm, about), undefined);
+            // One row per revision, and a Horn can bring two of those, so the Horn is what is counted and the
+            // first row for each is the one read.
+            const firstRows = new Map();
+            for (const row of found.results.bindings) {
+                const hornIri = row["horn"]?.value;
+                if (isPresent(hornIri) && !firstRows.has(hornIri))
+                    firstRows.set(hornIri, row);
+            }
+            if (firstRows.size === 0) {
+                const made = (await hornForRule({ select, realm, datastoreId, about })) ??
+                    (await hornForPlan({ select, realm, datastoreId, about }));
+                return made === undefined
+                    ? Response.json({ horns: [], total: 0 }, { headers: noStore })
+                    : Response.json({ horns: [{ horn: made, kept: false }], total: 0 }, { headers: noStore });
+            }
+            const wanted = [...firstRows.entries()].slice(0, asked);
+            const read = await Promise.all(wanted.map(async ([hornIri, row]) => {
+                const revision = row["revision"]?.value;
+                if (!isPresent(revision))
+                    return undefined;
+                const one = await hornAtRevision({ select, realm, hornIri, revision, number: Number(row["number"]?.value) });
+                if (one === undefined)
+                    return undefined;
+                const slug = row["slug"]?.value;
+                return {
+                    horn: one.horn,
+                    kept: true,
+                    revision,
+                    contentHash: await contentHash(one.stored),
+                    ...(isPresent(slug) ? { slug } : {}),
+                };
+            }));
+            // A revision that no longer reads as a Horn is left out rather than failing the lot: the others are
+            // still worth drawing, and `total` already says more exist.
+            return Response.json({ horns: read.filter(isPresent), total: firstRows.size }, { headers: noStore });
+        }
+        catch (caught) {
+            return refuse(502, caught instanceof Error ? caught.message : String(caught)).response;
+        }
+    });
     routes.get("/api/d/:datastoreId/horns/by/about", async (c) => {
         const datastoreId = c.req.param("datastoreId");
         const authorized = await authorize(c.req.raw, c.env, datastoreId);

package/dist/studio-agent-class.d.ts

@@ -23,6 +23,8 @@ export declare class HornStudioAgent extends Think<StudioAgentEnv, StudioAgentSt
     onConnect(connection: Connection, ctx: ConnectionContext): void | Promise<void>;
     private get opened();
     private get realm();
+    /** How a turn reaches agents, as the viewer and through the host's own upstream where it has one. */
+    private get caller();
     private select;
     getModel(): LanguageModel;
     /** Where the draft has got to: nothing drawn is designing, drawn but unbound is hydrating. */

package/dist/studio-agent-class.js

@@ -42,13 +42,17 @@ export class HornStudioAgent extends Think {
     get realm() {
         return this.opened.realm;
     }
-    select() {
-        return agentsSparqlSelect({
+    /** How a turn reaches agents, as the viewer and through the host's own upstream where it has one. */
+    get caller() {
+        return {
             agentsUrl: this.env.MANTA_AGENTS_URL,
             upstream: this.env.UPSTREAM,
             session: this.opened.session,
             datastoreId: this.opened.datastoreId,
-        });
+        };
+    }
+    select() {
+        return agentsSparqlSelect(this.caller);
     }
     getModel() {
         const chosen = studioModel(this.env);
@@ -116,11 +120,7 @@ export class HornStudioAgent extends Think {
                 lookup: () => undefined,
                 ...(deps.typecheck ? { typecheck: deps.typecheck } : {}),
                 // As the viewer: staging a rule is attributed to a person, and agents refuses it otherwise.
-                stageRule: (rule) => stageRule({
-                    agentsUrl: this.env.MANTA_AGENTS_URL,
-                    session: this.opened.session,
-                    datastoreId: this.opened.datastoreId,
-                }, rule),
+                stageRule: (rule) => stageRule(this.caller, rule),
             }),
         };
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/horns-server",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The Manta Horns worker as a library: Hono routes a Cloudflare host mounts on its own app.",
   "license": "MIT",
   "repository": {
@@ -59,8 +59,8 @@
     "@ai-sdk/google-vertex": "^5.0.101",
     "@ai-sdk/openai-compatible": "^3.0.62",
     "@cloudflare/think": "0.19.0",
-    "@manta-eu/client": "0.1.5",
-    "@manta-eu/lib": "0.1.5",
+    "@manta-eu/client": "0.1.7",
+    "@manta-eu/lib": "0.1.7",
     "@sentry/cloudflare": "^10.70.0",
     "@sentry/core": "^10.70.0",
     "agents": "^0.24.0",
@@ -70,8 +70,8 @@
     "sparqljs": "^3.7.4",
     "typescript": "^5.9.0",
     "zod": "^4.5.4",
-    "@manta-eu/horns": "0.2.0",
-    "@manta-eu/horns-kit": "0.2.0"
+    "@manta-eu/horns": "0.2.2",
+    "@manta-eu/horns-kit": "0.2.2"
   },
   "devDependencies": {
     "@cloudflare/vite-plugin": "1.47.0",