@manta-eu/horns-server 0.1.4 → 0.2.1

package/dist/studio-worker.js

@@ -0,0 +1,34 @@
+// A whole Horns worker, Studio included, from the three things a build has to hand it.
+//
+// `worker.ts` cannot reach the Studio itself: the conversation object imports `cloudflare:workers`, which
+// that module must stay clear of so Node can load it. This entry may, so it does the wiring a host would
+// otherwise repeat — registering what the Studio reads, and mounting its routes.
+import { Hono } from "hono";
+import { createTypecheck } from "./typecheck.js";
+import { createHornsWorker } from "./worker.js";
+import { provideStudioDeps, studioAgentRoutes } from "./studio-agent-routes.js";
+export { HornStudioAgent } from "./studio-agent-class.js";
+export function createHornsStudioWorker(options) {
+    const { shapes, componentApi, typecheckFs, routes, ...rest } = options;
+    const typecheck = typecheckFs === undefined ? undefined : createTypecheck(typecheckFs);
+    const parts = {
+        shapes,
+        ...(componentApi ? { componentApi } : {}),
+        ...(typecheck ? { typecheck } : {}),
+    };
+    // Registered rather than passed: the conversation object is built by the runtime, not by this call.
+    provideStudioDeps(parts);
+    return createHornsWorker({
+        ...rest,
+        ...parts,
+        routes: mount(routes),
+    });
+}
+// Hono's `route` mutates what it is called on, so a host's own app is composed into a fresh one rather than
+// having the Studio's routes added to it. The host's come first.
+function mount(routes) {
+    const app = new Hono();
+    if (routes !== undefined)
+        app.route("/", routes);
+    return app.route("/", studioAgentRoutes());
+}

package/dist/worker.d.ts

@@ -2,13 +2,18 @@ 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" | "componentApi" | "typecheck"> & Partial<Pick<StudioRoutesDeps<Env>, "criticModel">>;
+export type HornsWorkerOptions = Pick<StudioRoutesDeps<Env>, "shapes" | "componentApi" | "typecheck"> & Partial<Pick<StudioRoutesDeps<Env>, "criticModel">> & {
+    /** A host's own routes, mounted before the assets catch-all. */
+    routes?: Hono<{
+        Bindings: Env;
+    }>;
+};
 /**
  * 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, componentApi, typecheck, criticModel, }: HornsWorkerOptions): Hono<{
+export declare function createHornsApp({ shapes, componentApi, typecheck, routes, 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>;
+export declare function createHornsWorker(options: HornsWorkerOptions): ExportedHandler<Env, unknown, unknown, unknown>;

package/dist/worker.js

@@ -8,7 +8,7 @@ import { hornRoutes } from "./horn-routes.js";
 import { actionPlanRoutes } from "./action-plan-routes.js";
 import { studioRoutes } from "./studio-routes.js";
 import { contentSecurityPolicy } from "./csp.js";
-import { criticModelFromEnv } from "./llm.js";
+import { criticModel as criticModelFromEnv } from "./studio-model.js";
 import { requestSession } from "./dev-session.js";
 import { sessionCookiePrefixOf } from "./session.js";
 import { asJsonRequest, followedLink, noPageToOpen, signInFirst } from "./entity-links.js";
@@ -18,7 +18,7 @@ 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, componentApi, typecheck, criticModel = criticModelFromEnv, }) {
+export function createHornsApp({ shapes, componentApi, typecheck, routes, criticModel = (env) => criticModelFromEnv(env), }) {
     const app = new Hono();
     // On the document only: a JSON answer nobody renders has nothing to protect, and the header is not small.
     app.use("*", async (c, next) => {
@@ -180,6 +180,10 @@ export function createHornsApp({ shapes, componentApi, typecheck, criticModel =
         ...(componentApi ? { componentApi } : {}),
         ...(typecheck ? { typecheck } : {}),
     }));
+    // A host's own routes, mounted before the assets catch-all. The Studio conversation arrives this way:
+    // importing it pulls in `cloudflare:workers`, which this module must not do.
+    if (routes)
+        app.route("/", routes);
     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 } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manta-eu/horns-server",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "The Manta Horns worker as a library: Hono routes a Cloudflare host mounts on its own app.",
   "license": "MIT",
   "repository": {
@@ -26,13 +26,29 @@
       "types": "./dist/shared.d.ts",
       "default": "./dist/shared.js"
     },
-    "./llm": {
-      "types": "./dist/llm.d.ts",
-      "default": "./dist/llm.js"
-    },
     "./typecheck": {
       "types": "./dist/typecheck.d.ts",
       "default": "./dist/typecheck.js"
+    },
+    "./studio-model": {
+      "types": "./dist/studio-model.d.ts",
+      "default": "./dist/studio-model.js"
+    },
+    "./studio-agent": {
+      "types": "./dist/studio-agent-routes.d.ts",
+      "default": "./dist/studio-agent-routes.js"
+    },
+    "./studio-agent-class": {
+      "types": "./dist/studio-agent-class.d.ts",
+      "default": "./dist/studio-agent-class.js"
+    },
+    "./session": {
+      "types": "./dist/session.d.ts",
+      "default": "./dist/session.js"
+    },
+    "./studio-worker": {
+      "types": "./dist/studio-worker.d.ts",
+      "default": "./dist/studio-worker.js"
     }
   },
   "publishConfig": {
@@ -40,20 +56,26 @@
     "access": "public"
   },
   "dependencies": {
+    "@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",
     "@sentry/cloudflare": "^10.70.0",
     "@sentry/core": "^10.70.0",
+    "agents": "^0.24.0",
+    "ai": "^7.0.98",
     "hono": "^4.9.8",
     "ldkit": "2.9.0",
     "sparqljs": "^3.7.4",
     "typescript": "^5.9.0",
     "zod": "^4.5.4",
-    "@manta-eu/horns": "0.1.4",
-    "@manta-eu/horns-kit": "0.1.4"
+    "@manta-eu/horns": "0.2.1",
+    "@manta-eu/horns-kit": "0.2.1"
   },
   "devDependencies": {
     "@cloudflare/vite-plugin": "1.47.0",
+    "@cloudflare/workers-types": "^5.20261001.1",
     "@types/sparqljs": "^3.1.12",
     "rimraf": "^6.1.3",
     "typescript": "^5.9.0",

package/dist/llm.d.ts

@@ -1,45 +0,0 @@
-import { type StudioModel } from "@manta-eu/horns/studio";
-export type StudioModelEnv = {
-    HORNS_LLM_BASE_URL?: string;
-    HORNS_LLM_MODEL?: string;
-    /**
-     * `vllm` (the default) for the self-hosted Qwen, `openai` for anything else behind the gateway's
-     * OpenAI-compatible route — Anthropic, OpenAI. It decides whether `chat_template_kwargs` is sent and
-     * whether we carry a key of our own, because on any route but vLLM's the gateway holds the provider key.
-     */
-    HORNS_LLM_DIALECT?: string;
-    HORNS_LLM_MAX_TOKENS?: string;
-    VLLM_PRIMARY_AUTH_TOKEN?: string;
-    CLOUDFLARE_AI_GATEWAY_TOKEN?: string;
-    CLOUDFLARE_ENV?: string;
-    /** The critic, on its own gateway route: a model that can look at a picture of what the Studio drew. */
-    HORNS_CRITIC_BASE_URL?: string;
-    HORNS_CRITIC_MODEL?: string;
-    HORNS_CRITIC_DIALECT?: string;
-};
-export declare const aiGatewayHost = "gateway.ai.cloudflare.com";
-export declare const defaultMaxTokens = 6000;
-export type StudioModelResult = {
-    ok: true;
-    model: StudioModel;
-    monitored: boolean;
-} | {
-    ok: false;
-    reason: string;
-};
-export declare function studioModelFromEnv(env: StudioModelEnv, context: {
-    feature: string;
-    datastoreId?: string;
-}, fetcher?: typeof fetch): StudioModelResult;
-/**
- * The critic's model, which is not the Studio's: it reads a picture of what the Studio drew, so it has to be a
- * model with image input. It goes through the same gateway for the same reason — every call is logged — but it
- * carries no key of ours. The gateway holds the provider key and injects it; sending one of ours would
- * override the stored key with something the provider never issued.
- *
- * Unconfigured is not an error: the caller falls back to the Studio's own model, which reads the card as text.
- */
-export declare function criticModelFromEnv(env: StudioModelEnv, context: {
-    feature: string;
-    datastoreId?: string;
-}, fetcher?: typeof fetch): StudioModelResult;

package/dist/llm.js

@@ -1,124 +0,0 @@
-import { isPresent } from "@manta-eu/lib/present";
-import { createOpenAICompatibleModel } from "@manta-eu/horns/studio";
-/** Anything but an explicit `openai` is vLLM, so a deployment that says nothing keeps the Qwen it had. */
-function dialectOf(configured) {
-    return configured?.trim().toLowerCase() === "openai" ? "openai" : "vllm";
-}
-export const aiGatewayHost = "gateway.ai.cloudflare.com";
-// A round that runs past the gateway's ~100 s limit comes back as a timeout instead of an answer. Studio
-// rounds need around 3000 tokens, so this bounds a runaway thinking chain without cutting a real answer.
-export const defaultMaxTokens = 6000;
-const loopbackHosts = new Set(["localhost", "127.0.0.1", "[::1]"]);
-function maxTokensOf(configured) {
-    const parsed = Number(configured);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : defaultMaxTokens;
-}
-// Every Qwen call goes through agents' AI Gateway route (`custom-vllm-manta`), so it is logged and metered
-// beside agents' own traffic and tagged as Horns'. The one exception is a loopback LLM stub in tests.
-export function studioModelFromEnv(env, context, fetcher) {
-    const baseURL = env.HORNS_LLM_BASE_URL;
-    const model = env.HORNS_LLM_MODEL;
-    if (!isPresent(baseURL) || !isPresent(model)) {
-        return { ok: false, reason: "HORNS_LLM_BASE_URL and HORNS_LLM_MODEL must both be set." };
-    }
-    if (!URL.canParse(baseURL))
-        return { ok: false, reason: "HORNS_LLM_BASE_URL is not a URL." };
-    const { hostname, protocol } = new URL(baseURL);
-    const dialect = dialectOf(env.HORNS_LLM_DIALECT);
-    const withFetch = fetcher ? { fetch: fetcher } : {};
-    if (loopbackHosts.has(hostname)) {
-        return {
-            ok: true,
-            monitored: false,
-            model: createOpenAICompatibleModel({ baseURL, model, dialect, ...withFetch }),
-        };
-    }
-    if (protocol !== "https:" || hostname !== aiGatewayHost) {
-        return {
-            ok: false,
-            reason: `HORNS_LLM_BASE_URL must be the AI Gateway (${aiGatewayHost}) so model calls are logged, not ${hostname}.`,
-        };
-    }
-    if (!isPresent(env.CLOUDFLARE_AI_GATEWAY_TOKEN)) {
-        return { ok: false, reason: "CLOUDFLARE_AI_GATEWAY_TOKEN must be set to call the AI Gateway." };
-    }
-    // Only vLLM's route takes a key of ours. On any other the gateway holds the provider key, and sending one
-    // would override the stored key with something the provider never issued.
-    if (dialect === "vllm" && !isPresent(env.VLLM_PRIMARY_AUTH_TOKEN)) {
-        return { ok: false, reason: "VLLM_PRIMARY_AUTH_TOKEN must be set for the gateway's vLLM route." };
-    }
-    return {
-        ok: true,
-        monitored: true,
-        model: createOpenAICompatibleModel({
-            baseURL,
-            model,
-            dialect,
-            ...(dialect === "vllm" && isPresent(env.VLLM_PRIMARY_AUTH_TOKEN) ? { apiKey: env.VLLM_PRIMARY_AUTH_TOKEN } : {}),
-            gatewayToken: env.CLOUDFLARE_AI_GATEWAY_TOKEN,
-            maxTokens: maxTokensOf(env.HORNS_LLM_MAX_TOKENS),
-            // No user identifiers: the gateway log is shared with agents.
-            metadata: {
-                app: "manta-horns",
-                environment: env.CLOUDFLARE_ENV ?? "local",
-                feature: context.feature,
-                ...(isPresent(context.datastoreId) ? { datastore: context.datastoreId } : {}),
-            },
-            ...withFetch,
-        }),
-    };
-}
-/**
- * The critic's model, which is not the Studio's: it reads a picture of what the Studio drew, so it has to be a
- * model with image input. It goes through the same gateway for the same reason — every call is logged — but it
- * carries no key of ours. The gateway holds the provider key and injects it; sending one of ours would
- * override the stored key with something the provider never issued.
- *
- * Unconfigured is not an error: the caller falls back to the Studio's own model, which reads the card as text.
- */
-export function criticModelFromEnv(env, context, fetcher) {
-    const baseURL = env.HORNS_CRITIC_BASE_URL;
-    const model = env.HORNS_CRITIC_MODEL;
-    if (!isPresent(baseURL) || !isPresent(model)) {
-        return { ok: false, reason: "HORNS_CRITIC_BASE_URL and HORNS_CRITIC_MODEL must both be set." };
-    }
-    if (!URL.canParse(baseURL))
-        return { ok: false, reason: "HORNS_CRITIC_BASE_URL is not a URL." };
-    const { hostname, protocol } = new URL(baseURL);
-    const dialect = dialectOf(env.HORNS_CRITIC_DIALECT);
-    const withFetch = fetcher ? { fetch: fetcher } : {};
-    if (loopbackHosts.has(hostname)) {
-        return {
-            ok: true,
-            monitored: false,
-            model: createOpenAICompatibleModel({ baseURL, model, dialect, ...withFetch }),
-        };
-    }
-    if (protocol !== "https:" || hostname !== aiGatewayHost) {
-        return {
-            ok: false,
-            reason: `HORNS_CRITIC_BASE_URL must be the AI Gateway (${aiGatewayHost}) so critic calls are logged, not ${hostname}.`,
-        };
-    }
-    if (!isPresent(env.CLOUDFLARE_AI_GATEWAY_TOKEN)) {
-        return { ok: false, reason: "CLOUDFLARE_AI_GATEWAY_TOKEN must be set to call the AI Gateway." };
-    }
-    return {
-        ok: true,
-        monitored: true,
-        model: createOpenAICompatibleModel({
-            baseURL,
-            model,
-            dialect,
-            gatewayToken: env.CLOUDFLARE_AI_GATEWAY_TOKEN,
-            maxTokens: maxTokensOf(env.HORNS_LLM_MAX_TOKENS),
-            metadata: {
-                app: "manta-horns",
-                environment: env.CLOUDFLARE_ENV ?? "local",
-                feature: context.feature,
-                ...(isPresent(context.datastoreId) ? { datastore: context.datastoreId } : {}),
-            },
-            ...withFetch,
-        }),
-    };
-}