@retinue/agentkit 0.1.0

package/dist/server/config.js

@@ -0,0 +1,127 @@
+/**
+ * Deployment configuration (#110).
+ *
+ * Lives here rather than in `@retinue/agentkit`, and that is deliberate: the library reads
+ * `process.env` **zero times**, so a host can configure it however it likes — from a file, a secret
+ * manager, a test fixture. A library that reads the environment cannot be configured by its host, and
+ * that property erodes one convenient `process.env.DATABASE_URL` at a time, so there is a test for it.
+ *
+ * `loadConfig` takes the environment as an argument for the same reason. It makes "fails with a
+ * message naming the problem" testable without mutating global state, and it means a caller can load
+ * configuration from somewhere that is not `process.env` at all.
+ */
+import { readEnv } from "../core/env.js";
+/** Thrown when configuration is unusable. Carries the variable names so the message is actionable. */
+export class ConfigurationError extends Error {
+    variables;
+    constructor(problems, variables) {
+        super(`Invalid configuration:\n  - ${problems.join("\n  - ")}`);
+        this.name = "ConfigurationError";
+        this.variables = variables;
+    }
+}
+const SCHEMA_MODES = ["auto", "plan", "off"];
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+export const DEFAULT_CONFIG = {
+    schemaMode: "off",
+    port: 4000,
+    workerConcurrency: 4,
+    logLevel: "info",
+};
+/**
+ * Validate the whole environment and report **every** problem at once.
+ *
+ * Deliberately not fail-on-first: a deployment with three missing variables should learn all three
+ * from one boot, not discover them across three deploys. That is what "fail fast with a precise
+ * message" is actually worth.
+ */
+export const loadConfig = (env) => {
+    const problems = [];
+    const variables = [];
+    const fail = (variable, problem) => {
+        problems.push(`${variable}: ${problem}`);
+        variables.push(variable);
+    };
+    /**
+     * The prefix is added here, not written at each call — #192.
+     *
+     * Every variable was `AGENTKIT_*` and is now `RETINUE_*`. `readEnv` accepts both and warns on the old one, so
+     * a deployment keeps working for one release while it is corrected. Adding the prefix in one place means a
+     * caller cannot accidentally name the legacy variable directly and skip the warning.
+     *
+     * Errors always name the **current** variable, because an error naming the deprecated one would teach the
+     * reader to set the wrong thing.
+     */
+    const lookup = (suffix) => readEnv(env, suffix);
+    const named = (suffix) => `RETINUE_${suffix}`;
+    const required = (suffix) => {
+        const variable = named(suffix);
+        const value = lookup(suffix);
+        if (value === undefined || value.trim() === "") {
+            // Named, because "invalid configuration" without the name means reading the source to deploy.
+            fail(variable, "is required but was not set");
+            return "";
+        }
+        return value;
+    };
+    const databaseUrl = required("DATABASE_URL");
+    if (databaseUrl !== "" && !/^postgres(ql)?:\/\//.test(databaseUrl)) {
+        fail(named("DATABASE_URL"), `must be a postgres:// URL, got "${databaseUrl.slice(0, 12)}…"`);
+    }
+    const redisUrl = required("REDIS_URL");
+    if (redisUrl !== "" && !/^rediss?:\/\//.test(redisUrl)) {
+        fail(named("REDIS_URL"), `must be a redis:// URL, got "${redisUrl.slice(0, 12)}…"`);
+    }
+    const rawSchemaMode = lookup("SCHEMA_MODE") ?? DEFAULT_CONFIG.schemaMode;
+    if (!SCHEMA_MODES.includes(rawSchemaMode)) {
+        fail(named("SCHEMA_MODE"), `must be one of ${SCHEMA_MODES.join(", ")}, got "${rawSchemaMode}"`);
+    }
+    const positiveInt = (suffix, fallback) => {
+        // `PORT` has no prefix — it is the conventional name and always has been, so it is read directly.
+        const variable = suffix === "PORT" ? "PORT" : named(suffix);
+        const raw = suffix === "PORT" ? env["PORT"] : lookup(suffix);
+        if (raw === undefined || raw.trim() === "")
+            return fallback;
+        const value = Number(raw);
+        if (!Number.isInteger(value) || value <= 0) {
+            // A zero concurrency is the interesting case: it boots a worker that consumes nothing and looks
+            // healthy, which is worse than refusing to start.
+            fail(variable, `must be a positive integer, got "${raw}"`);
+            return fallback;
+        }
+        return value;
+    };
+    const port = positiveInt("PORT", DEFAULT_CONFIG.port);
+    const workerConcurrency = positiveInt("WORKER_CONCURRENCY", DEFAULT_CONFIG.workerConcurrency);
+    const rawLogLevel = lookup("LOG_LEVEL") ?? DEFAULT_CONFIG.logLevel;
+    if (!LOG_LEVELS.includes(rawLogLevel)) {
+        fail(named("LOG_LEVEL"), `must be one of ${LOG_LEVELS.join(", ")}, got "${rawLogLevel}"`);
+    }
+    if (problems.length > 0)
+        throw new ConfigurationError(problems, variables);
+    return {
+        databaseUrl,
+        redisUrl,
+        schemaMode: rawSchemaMode,
+        port,
+        workerConcurrency,
+        logLevel: rawLogLevel,
+    };
+};
+/** The variables a deployment must set, for the README and for error messages to stay in step. */
+/**
+ * The variables a deployment must set, by their **full current names**.
+ *
+ * The prefix belongs here even though `lookup` adds it internally: this is what a deployment reads to know what
+ * to configure, and a list saying `DATABASE_URL` would have people setting a variable nothing reads. The rename
+ * briefly stripped it — a regex over the file caught this constant along with the internal literals — and the
+ * test that asserts the error names every missing variable is what found it.
+ */
+export const REQUIRED_VARIABLES = ["RETINUE_DATABASE_URL", "RETINUE_REDIS_URL"];
+export const OPTIONAL_VARIABLES = [
+    "SCHEMA_MODE",
+    "WORKER_CONCURRENCY",
+    "LOG_LEVEL",
+    "PORT",
+];
+//# sourceMappingURL=config.js.map

package/dist/server/health.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Health and readiness probes (#110).
+ *
+ * `/healthz` and `/readyz` answer different questions, and conflating them is the mistake this file
+ * exists to avoid.
+ *
+ * **`/healthz` — is this process alive?** It must succeed while the database is down. An orchestrator
+ * that restarts a process because a *dependency* is unavailable turns a brief database blip into a
+ * restart storm, and the restarted process is no more able to reach the database than the one it
+ * replaced.
+ *
+ * **`/readyz` — should traffic come here?** Dependencies reachable, schema at the expected version.
+ * Not-ready is a **503**, because a load balancer keys off the status code, not the body — a 200 with
+ * `{"ready": false}` is a page nobody gets.
+ */
+/** One dependency check. Failing is expected and normal; throwing is treated as failing. */
+export type Probe = {
+    readonly name: string;
+    readonly check: () => Promise<void> | void;
+};
+export type ProbeResult = {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly error?: string;
+};
+export type HealthRoutesOptions = {
+    readonly probes: readonly Probe[];
+    /** Reported in the payload so an operator can tell which build answered. */
+    readonly version?: string;
+    readonly healthPath?: string;
+    readonly readyPath?: string;
+};
+export declare const createHealthRoutes: (options: HealthRoutesOptions) => {
+    healthPath: string;
+    readyPath: string;
+    /** Liveness. Deliberately touches nothing external. */
+    health(): Response;
+    ready(): Promise<Response>;
+    /** Returns null when the path is not one of ours, so a host can compose this into its handler. */
+    handle(request: Request): Promise<Response | null>;
+};
+export type HealthRoutes = ReturnType<typeof createHealthRoutes>;
+/** `SELECT 1`. The cheapest question that distinguishes "reachable" from "resolves in DNS". */
+export declare const postgresProbe: (sql: {
+    query(text: string): Promise<unknown>;
+}) => Probe;
+export declare const redisProbe: (redis: {
+    ping(): Promise<string>;
+}) => Probe;
+/**
+ * Schema version. Separate from the Postgres probe on purpose: "the database is unreachable" and "the
+ * database is reachable but the schema is behind" need different operator responses, and a single
+ * probe would report them identically.
+ */
+export declare const schemaProbe: (manager: {
+    currentVersion(): Promise<number>;
+    targetVersion(): number;
+}) => Probe;
+//# sourceMappingURL=health.d.ts.map

package/dist/server/health.js

@@ -0,0 +1,90 @@
+/**
+ * Health and readiness probes (#110).
+ *
+ * `/healthz` and `/readyz` answer different questions, and conflating them is the mistake this file
+ * exists to avoid.
+ *
+ * **`/healthz` — is this process alive?** It must succeed while the database is down. An orchestrator
+ * that restarts a process because a *dependency* is unavailable turns a brief database blip into a
+ * restart storm, and the restarted process is no more able to reach the database than the one it
+ * replaced.
+ *
+ * **`/readyz` — should traffic come here?** Dependencies reachable, schema at the expected version.
+ * Not-ready is a **503**, because a load balancer keys off the status code, not the body — a 200 with
+ * `{"ready": false}` is a page nobody gets.
+ */
+export const createHealthRoutes = (options) => {
+    const healthPath = options.healthPath ?? "/healthz";
+    const readyPath = options.readyPath ?? "/readyz";
+    const runProbes = async () => 
+    // All probes run, always — a 503 that names only the first failure sends an operator round the
+    // loop once per broken dependency.
+    Promise.all(options.probes.map(async (probe) => {
+        try {
+            await probe.check();
+            return { name: probe.name, ok: true };
+        }
+        catch (error) {
+            return { name: probe.name, ok: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }));
+    return {
+        healthPath,
+        readyPath,
+        /** Liveness. Deliberately touches nothing external. */
+        health() {
+            return Response.json({ status: "ok", ...(options.version === undefined ? {} : { version: options.version }) }, { status: 200 });
+        },
+        async ready() {
+            const results = await runProbes();
+            const ok = results.every((r) => r.ok);
+            return Response.json({
+                status: ok ? "ready" : "not-ready",
+                ...(options.version === undefined ? {} : { version: options.version }),
+                probes: results,
+            }, 
+            // 503, not 200-with-a-flag: the load balancer reads the status.
+            { status: ok ? 200 : 503 });
+        },
+        /** Returns null when the path is not one of ours, so a host can compose this into its handler. */
+        async handle(request) {
+            const { pathname } = new URL(request.url);
+            if (pathname === healthPath)
+                return this.health();
+            if (pathname === readyPath)
+                return this.ready();
+            return null;
+        },
+    };
+};
+/** `SELECT 1`. The cheapest question that distinguishes "reachable" from "resolves in DNS". */
+export const postgresProbe = (sql) => ({
+    name: "postgres",
+    check: async () => {
+        await sql.query("SELECT 1");
+    },
+});
+export const redisProbe = (redis) => ({
+    name: "redis",
+    check: async () => {
+        const reply = await redis.ping();
+        if (reply !== "PONG")
+            throw new Error(`unexpected PING reply: ${reply}`);
+    },
+});
+/**
+ * Schema version. Separate from the Postgres probe on purpose: "the database is unreachable" and "the
+ * database is reachable but the schema is behind" need different operator responses, and a single
+ * probe would report them identically.
+ */
+export const schemaProbe = (manager) => ({
+    name: "schema",
+    check: async () => {
+        const current = await manager.currentVersion();
+        const target = manager.targetVersion();
+        if (current !== target) {
+            throw new Error(`schema at version ${current}, expected ${target}`);
+        }
+    },
+});
+//# sourceMappingURL=health.js.map

package/dist/server/host.d.ts

@@ -0,0 +1,39 @@
+import { type SseRouteOptions } from "./sse-route.js";
+import type { HealthRoutes } from "./health.js";
+import type { GraphQLContext, ResolverDeps } from "../index.js";
+import type { ExecutionContext } from "../index.js";
+/**
+ * Turns a request into an execution context, or `null` to refuse it.
+ *
+ * Deliberately the caller's function. Identity is the one thing a library cannot supply — it depends
+ * on the deployment's identity provider — and a default would be worse than an absent one. Note the
+ * consequence, recorded as an open question on #108: the security-critical step is entirely the
+ * caller's, and nothing here can verify it does the right thing.
+ */
+export type Authenticate = (request: Request) => Promise<ExecutionContext | null> | ExecutionContext | null;
+export type HostOptions = {
+    readonly deps: ResolverDeps;
+    readonly authenticate: Authenticate;
+    /** GraphQL endpoint path. Defaults to `/graphql`. */
+    readonly graphqlEndpoint?: string;
+    /** Landing page and introspection are off by default; a reference host is not a playground. */
+    readonly graphiql?: boolean;
+    /**
+     * Also serve the SSE streaming endpoint (#109) on the same fetch handler. Optional because the
+     * embedded profile is one deployment shape, not the only one — a host using GraphQL subscriptions
+     * exclusively should not have a second streaming surface it never wanted.
+     */
+    readonly sse?: Omit<SseRouteOptions, "deps" | "authenticate"> & {
+        readonly enabled: boolean;
+    };
+    /**
+     * Health and readiness routes, served **before** authentication. Deliberately: a load balancer has
+     * no credentials, and a probe that required them would report every healthy pod as unhealthy.
+     */
+    readonly health?: HealthRoutes;
+};
+/** Thrown when a request carries no usable identity. Surfaces as a GraphQL error, not a crash. */
+export declare const UNAUTHENTICATED = "UNAUTHENTICATED";
+export declare const createRetinueHost: (options: HostOptions) => import("graphql-yoga").YogaServerInstance<Record<string, never>, GraphQLContext>;
+export type RetinueHost = ReturnType<typeof createRetinueHost>;
+//# sourceMappingURL=host.d.ts.map

package/dist/server/host.js

@@ -0,0 +1,124 @@
+/**
+ * Reference GraphQL host (#108).
+ *
+ * `@retinue/agentkit` ships the schema as SDL and a thin resolver map with **no server dependency**,
+ * so a host can mount it on Yoga, Apollo or Mercurius. This is one such host, in its own workspace
+ * precisely so the library keeps that property — AC-6 of #108 is that `@retinue/agentkit` gained no
+ * GraphQL-server dependency, and putting Yoga inside it would have failed that outright.
+ *
+ * It is a *reference* host, not the sanctioned one. Nothing here is business logic: the resolver map
+ * is passed through untouched, and the only thing this layer decides is where the `ExecutionContext`
+ * comes from.
+ */
+import { createGraphQLError, createSchema, createYoga } from "graphql-yoga";
+import { createServerAdapter } from "@whatwg-node/server";
+import { createRunEventSseRoute } from "./sse-route.js";
+import { createResolvers, typeDefs } from "../graphql/index.js";
+/** Thrown when a request carries no usable identity. Surfaces as a GraphQL error, not a crash. */
+export const UNAUTHENTICATED = "UNAUTHENTICATED";
+export const createRetinueHost = (options) => {
+    // Passed through untouched. AC-5 is "no business logic was added to the resolver layer", and the
+    // strongest form of that is a host that adds no resolver of its own — asserted in the tests.
+    const resolvers = createResolvers(options.deps);
+    const yoga = createYoga({
+        schema: createSchema({ typeDefs, resolvers: resolvers }),
+        graphqlEndpoint: options.graphqlEndpoint ?? "/graphql",
+        graphiql: options.graphiql ?? false,
+        landingPage: false,
+        /**
+         * The single place an `ExecutionContext` is constructed, which is what makes AC-2 and AC-3 one
+         * mechanism rather than two.
+         *
+         * Yoga runs this **before execution**, so throwing here means no resolver runs — that is AC-2,
+         * and it is a stronger statement than "the response was a 401". And because this is the only
+         * construction site, there is no ambient or default tenant for a request to fall back to, which
+         * is AC-3. A resolver cannot see a context it did not construct because there is nowhere else for
+         * one to come from.
+         */
+        context: async ({ request }) => {
+            const execution = await options.authenticate(request);
+            if (execution === null || execution === undefined) {
+                // `createGraphQLError` rather than a bare `new GraphQLError`. Yoga masks errors it considers
+                // unexpected, and a context-factory throw is one of them — a plain GraphQLError comes back as
+                // a 500 "Unexpected error", which would turn an authentication refusal into what looks like a
+                // server fault. Verified: the first version of this did exactly that.
+                throw createGraphQLError("Unauthenticated", {
+                    extensions: { code: UNAUTHENTICATED, http: { status: 401 } },
+                });
+            }
+            return { execution };
+        },
+    });
+    const health = options.health;
+    if (options.sse?.enabled !== true && health === undefined)
+        return yoga;
+    const sse = options.sse?.enabled === true
+        ? createRunEventSseRoute({ deps: options.deps, authenticate: options.authenticate, ...options.sse })
+        : null;
+    /**
+     * One fetch handler for both surfaces. Composed rather than mounted on a router, because a router
+     * would be a second framework decision this workspace has no need to make — and the whole point of
+     * a fetch handler is that it composes.
+     */
+    /**
+     * Whether this is already a request.
+     *
+     * Duck-typed on `url` and `headers`, because there can be more than one `Request` class in a process and a
+     * nominal check picks the wrong one silently.
+     */
+    const isRequestLike = (value) => typeof value === "object" &&
+        value !== null &&
+        typeof value.url === "string" &&
+        typeof value.headers === "object";
+    const handle = async (input, init, ...rest) => {
+        /**
+         * Normalised **structurally**, not with `instanceof Request`.
+         *
+         * Yoga's `fetch` accepts a Request, a URL or a string, and callers use all three — the first version of this
+         * read `request.url` off a string and failed with "Invalid URL" for every caller that passed one.
+         *
+         * But `instanceof` was wrong too, and more subtly (#155). `@whatwg-node/server` — which Yoga itself is built
+         * on — constructs requests from its own ponyfilled class, so a genuine request arriving through the Node
+         * adapter is **not** `instanceof` the global `Request`. The check failed, the object fell through to
+         * `new Request(String(input))`, and every request died on `Failed to parse URL from [object Request]`.
+         *
+         * A request is a thing with a URL. Testing for that works across every implementation, which is the property
+         * that matters when two of them are in the same process.
+         */
+        const request = isRequestLike(input) ? input : new Request(String(input), init);
+        const url = new URL(request.url);
+        // Probes first and unauthenticated: a load balancer carries no credentials.
+        const probe = await health?.handle(request);
+        if (probe !== null && probe !== undefined)
+            return probe;
+        if (sse !== null && url.pathname === sse.path)
+            return sse.handle(request);
+        return yoga.fetch(request, ...rest);
+    };
+    /**
+     * A **server adapter**, so the returned object is both a fetch handler *and* a Node request listener.
+     *
+     * This was a real bug, found the first time anything actually served a request (#155). The previous version
+     * returned `Object.assign(fetch, yoga, …)` — a function whose callable body was the WHATWG `fetch`. Node's
+     * `http.createServer(listener)` calls its listener with `(IncomingMessage, ServerResponse)`, so
+     * `createServer(host)` reached `new Request(String(incomingMessage))` and threw
+     * `Failed to parse URL from [object Object]` on **every** request.
+     *
+     * The doc comment above it claimed "callers and `createServer(host)` are unaffected", and that claim had never
+     * been executed: the tests call `host.fetch(new Request(…))` directly, which is the one path that worked.
+     * `main.ts` — the documented way to run this — could not serve anything.
+     *
+     * `createServerAdapter` is what Yoga itself is built on, so this is the same conversion Yoga would have done,
+     * applied to the composed handler instead of to Yoga alone. Health probes and SSE now reach the Node path too;
+     * before, they were only reachable by a caller who already had a `Request`.
+     */
+    const adapter = createServerAdapter(handle);
+    // Yoga's own shape is preserved on top (`graphqlEndpoint`, `getEnveloped`, …) for callers that read it, and
+    // `fetch` is pinned to the adapter so one object serves both styles.
+    return Object.assign(adapter, yoga, {
+        fetch: adapter,
+        handle,
+        ...(sse === null ? {} : { ssePath: sse.path }),
+    });
+};
+//# sourceMappingURL=host.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@retinue/agentkit/server` — the reference GraphQL host for `@retinue/agentkit` (#108).
+ *
+ * A separate workspace on purpose: the library ships SDL plus a thin resolver map and takes no
+ * GraphQL-server dependency, so a host can mount it on Yoga, Apollo or Mercurius. This is one host.
+ */
+export * from "./host.js";
+export * from "./main.js";
+export * from "./sse-route.js";
+export * from "./config.js";
+export * from "./health.js";
+export * from "./boot.js";
+export * from "./cli.js";
+export * from "./cli-worker.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.js

@@ -0,0 +1,15 @@
+/**
+ * `@retinue/agentkit/server` — the reference GraphQL host for `@retinue/agentkit` (#108).
+ *
+ * A separate workspace on purpose: the library ships SDL plus a thin resolver map and takes no
+ * GraphQL-server dependency, so a host can mount it on Yoga, Apollo or Mercurius. This is one host.
+ */
+export * from "./host.js";
+export * from "./main.js";
+export * from "./sse-route.js";
+export * from "./config.js";
+export * from "./health.js";
+export * from "./boot.js";
+export * from "./cli.js";
+export * from "./cli-worker.js";
+//# sourceMappingURL=index.js.map

package/dist/server/main.d.ts

@@ -0,0 +1,16 @@
+import { type Authenticate } from "./host.js";
+import type { ResolverDeps } from "../index.js";
+export type MainOptions = {
+    readonly deps: ResolverDeps;
+    readonly authenticate: Authenticate;
+    readonly port?: number;
+    readonly log?: (message: string) => void;
+};
+export declare const DEFAULT_PORT = 4000;
+export declare const startServer: (options: MainOptions) => Promise<{
+    port: number;
+    yoga: import("graphql-yoga").YogaServerInstance<Record<string, never>, import("../index.js").GraphQLContext>;
+    /** Resolves once the socket is closed, so a caller can sequence shutdown. */
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=main.d.ts.map

package/dist/server/main.js

@@ -0,0 +1,31 @@
+/**
+ * Runnable entrypoint (#108 AC-1).
+ *
+ * Composition only. Every store, dispatcher and service it wires already exists and is already
+ * tested; this file's whole job is to be a documented command that serves the API.
+ *
+ * Run with:
+ *   RETINUE_DATABASE_URL=postgres://… PORT=4000 node dist/main.js
+ *
+ * `authenticate` is deliberately not implemented here. A reference host cannot know a deployment's
+ * identity provider, and shipping a permissive default would be worse than shipping none — so the
+ * entrypoint refuses to start without one rather than quietly serving an open API.
+ */
+import { createServer } from "node:http";
+import { createRetinueHost } from "./host.js";
+export const DEFAULT_PORT = 4000;
+export const startServer = async (options) => {
+    const port = options.port ?? Number(process.env["PORT"] ?? DEFAULT_PORT);
+    const log = options.log ?? ((message) => console.log(message));
+    const yoga = createRetinueHost({ deps: options.deps, authenticate: options.authenticate });
+    const server = createServer(yoga);
+    await new Promise((resolve) => server.listen(port, resolve));
+    log(`agentkit graphql host listening on :${port}${yoga.graphqlEndpoint}`);
+    return {
+        port,
+        yoga,
+        /** Resolves once the socket is closed, so a caller can sequence shutdown. */
+        close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))),
+    };
+};
+//# sourceMappingURL=main.js.map

package/dist/server/sse-route.d.ts

@@ -0,0 +1,21 @@
+import type { ConversationId, ExecutionContext, ResolverDeps } from "../index.js";
+import type { Authenticate } from "./host.js";
+export type SseRouteOptions = {
+    readonly deps: Pick<ResolverDeps, "conversations" | "eventLog" | "live" | "channelFor">;
+    readonly authenticate: Authenticate;
+    /**
+     * Finer-grained entitlement *within* a tenant, which the library cannot know. Optional: the
+     * cross-tenant case is already closed by the unconditional ownership check below, so this is for
+     * per-user policy rather than for the dangerous case.
+     */
+    readonly authorizeConversation?: (execution: ExecutionContext, conversationId: ConversationId) => Promise<boolean> | boolean;
+    /** How often a quiet stream emits a comment frame. Default 15s. */
+    readonly keepAliveMs?: number;
+    readonly path?: string;
+};
+export declare const createRunEventSseRoute: (options: SseRouteOptions) => {
+    path: string;
+    handle(request: Request): Promise<Response>;
+};
+export type RunEventSseRoute = ReturnType<typeof createRunEventSseRoute>;
+//# sourceMappingURL=sse-route.d.ts.map