@arnilo/prism-server 0.0.5

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.0.5] - 2026-07-16
+
+- Added optional authorized, bounded Web-standard direct/SSE agent and durable workflow handling, including explicitly registered ownership-scoped schedules, background enqueue, and immutable-lineage replay.
+
+## [0.0.4] - 2026-07-14
+
+- Initial optional web-standard agent/workflow handler with explicit authorization, ownership, redaction, streaming, and resource bounds.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# @arnilo/prism-server
+
+Optional framework-free Web `Request -> Response` exposure for selected Prism agents and workflows.
+
+```bash
+npm install @arnilo/prism @arnilo/prism-workflows @arnilo/prism-server
+```
+
+```ts
+import { createPrismHandler } from "@arnilo/prism-server";
+
+const handler = createPrismHandler({
+  agents: { support: agent },
+  workflows: { publish: { definition: workflow, checkpoints } },
+  authorize: async ({ request }) => validHostToken(request)
+    ? { ownership: { tenantId: "tenant-1", userId: "user-1" } }
+    : false,
+});
+
+const response = await handler(new Request("https://api.example.test/prism/agents/support/runs", {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify({ input: "Hello" }),
+}));
+```
+
+Routes: direct/SSE agent run, direct/SSE workflow run, durable workflow enqueue/status/cancel/resume/replay, and optional ownership-scoped schedule create/list/pause/resume/trigger/delete. All bodies, responses, events, queues, concurrency, and timeouts are bounded.
+
+Nothing is exposed by default. Authorization is required; ownership comes only from its result. No listener, framework, auth provider, user database, credential discovery, or hidden package activation ships.
+
+Full API, route, limits, security, and deployment notes: [`docs/server.md`](../../docs/server.md).

package/dist/handler.d.ts

@@ -0,0 +1,2 @@
+import type { CreatePrismHandlerOptions, PrismRequestHandler } from "./types.js";
+export declare function createPrismHandler(options: CreatePrismHandlerOptions): PrismRequestHandler;

package/dist/handler.js

@@ -0,0 +1,657 @@
+import { cancelWorkflowRun, createWorkflowEventBus, enqueueWorkflow, getWorkflowRun, replayWorkflow, resumeWorkflow, runWorkflow, } from "@arnilo/prism-workflows";
+import { resolvePrismServerLimits } from "./limits.js";
+import { PrismServerError } from "./types.js";
+const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
+const SSE_HEADERS = {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive",
+};
+export function createPrismHandler(options) {
+    const limits = resolvePrismServerLimits(options.limits);
+    const base = normalizeBasePath(options.basePath ?? "/prism");
+    let activeRuns = 0;
+    return async (request) => {
+        const origin = request.headers.get("origin");
+        const corsHeaders = origin && options.allowedOrigins?.includes(origin)
+            ? { "access-control-allow-origin": origin, vary: "origin" }
+            : undefined;
+        const respond = (response) => addHeaders(response, corsHeaders);
+        try {
+            assertRequestPolicy(request, options.allowedHosts, options.allowedOrigins);
+            const route = parseRoute(request, base);
+            if (request.method === "OPTIONS") {
+                if (!origin || !options.allowedOrigins?.includes(origin))
+                    throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                return respond(new Response(null, {
+                    status: 204,
+                    headers: {
+                        "access-control-allow-origin": origin,
+                        "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
+                        "access-control-allow-headers": "content-type, authorization",
+                        vary: "origin",
+                    },
+                }));
+            }
+            if (!route)
+                throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+            const authorization = await authorize(options, request, route.operation, route.capabilityId, limits.requestTimeoutMs);
+            if (!authorization)
+                throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+            if (route.kind.startsWith("schedule-")) {
+                const selectedSchedules = options.schedules;
+                if (!selectedSchedules)
+                    throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const schedules = typeof selectedSchedules === "function"
+                        ? await awaitWithSignal(Promise.resolve(selectedSchedules(authorization, owned.signal)), owned.signal)
+                        : selectedSchedules;
+                    if (!sameOwnership(authorization.ownership, schedules.ownership)) {
+                        throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+                    }
+                    if (route.kind === "schedule-list") {
+                        const query = new URL(request.url).searchParams;
+                        const status = query.get("status");
+                        const result = await awaitWithSignal(schedules.list({
+                            status: readScheduleStatus(status),
+                            cursor: query.get("cursor") ?? undefined,
+                            limit: query.has("limit") ? readPositiveInteger(query.get("limit"), "limit") : undefined,
+                            signal: owned.signal,
+                        }), owned.signal);
+                        return respond(json(result, 200, limits, options));
+                    }
+                    if (route.kind === "schedule-delete") {
+                        const result = await awaitWithSignal(schedules.delete(route.capabilityId, owned.signal), owned.signal);
+                        return respond(json({ deleted: result }, 200, limits, options));
+                    }
+                    const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                    if (route.kind === "schedule-create") {
+                        const result = await awaitWithSignal(schedules.create({
+                            id: route.capabilityId,
+                            workflowId: readRequiredId(body.workflowId, "workflowId"),
+                            nextRunAt: readRequiredString(body.nextRunAt, "nextRunAt"),
+                            input: body.input,
+                            intervalMs: body.intervalMs === undefined ? undefined : readPositiveInteger(body.intervalMs, "intervalMs"),
+                            calculatorId: readOptionalId(body.calculatorId, "calculatorId"),
+                            paused: body.paused === true,
+                            metadata: readOptionalObject(body.metadata, "metadata"),
+                        }, owned.signal), owned.signal);
+                        return respond(json(result, 201, limits, options));
+                    }
+                    if (route.kind === "schedule-pause") {
+                        return respond(json(await awaitWithSignal(schedules.pause(route.capabilityId, owned.signal), owned.signal), 200, limits, options));
+                    }
+                    if (route.kind === "schedule-resume") {
+                        const nextRunAt = body.nextRunAt === undefined ? undefined : readRequiredString(body.nextRunAt, "nextRunAt");
+                        return respond(json(await awaitWithSignal(schedules.resume(route.capabilityId, nextRunAt, owned.signal), owned.signal), 200, limits, options));
+                    }
+                    const idempotencyKey = readRequiredId(body.idempotencyKey, "idempotencyKey");
+                    return respond(json(await awaitWithSignal(schedules.trigger(route.capabilityId, { idempotencyKey, signal: owned.signal }), owned.signal), 200, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                }
+            }
+            if (route.kind === "agent-run" || route.kind === "agent-stream") {
+                const exposure = options.agents?.[route.capabilityId];
+                if (!exposure)
+                    throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                acquire();
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                    const input = readAgentInput(body.input);
+                    const { session, runOptions } = await awaitWithSignal(createSession(exposure, authorization), owned.signal);
+                    const runConfig = {
+                        ...runOptions,
+                        ownership: authorization.ownership,
+                        metadata: { ...runOptions?.metadata, ...authorization.metadata },
+                        redactor: options.redactor,
+                        signal: owned.signal,
+                    };
+                    if (route.kind === "agent-run") {
+                        const result = await awaitWithSignal(session.run(input, runConfig), owned.signal);
+                        const response = respond(json(result, 200, limits, options));
+                        owned.dispose();
+                        release();
+                        return response;
+                    }
+                    const events = session.stream(input, {
+                        ...runConfig,
+                        maxQueuedEvents: limits.maxQueuedEvents,
+                        overflow: "close",
+                    });
+                    return respond(sse(events, owned, limits, options, release));
+                }
+                catch (error) {
+                    owned.dispose();
+                    release();
+                    throw error;
+                }
+            }
+            const exposure = options.workflows?.[route.capabilityId];
+            if (!exposure)
+                throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+            if (route.kind === "workflow-enqueue") {
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                    const result = await awaitWithSignal(enqueueWorkflow(exposure.definition, body.input, {
+                        checkpoints: exposure.checkpoints,
+                        ownership: authorization.ownership,
+                        runId: readOptionalId(body.runId, "runId"),
+                        metadata: { ...exposure.runOptions?.metadata, ...authorization.metadata },
+                        signal: owned.signal,
+                    }), owned.signal);
+                    return respond(json(result, 202, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                }
+            }
+            if (route.kind === "workflow-replay") {
+                acquire();
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                    const result = await awaitWithSignal(replayWorkflow(exposure.definition, {
+                        sourceRunId: route.runId,
+                        fromNodeId: readRequiredId(body.fromNodeId, "fromNodeId"),
+                        runId: readOptionalId(body.runId, "runId"),
+                    }, {
+                        ...exposure.runOptions,
+                        checkpoints: exposure.checkpoints,
+                        ownership: authorization.ownership,
+                        metadata: { ...exposure.runOptions?.metadata, ...authorization.metadata },
+                        redactor: options.redactor,
+                        signal: owned.signal,
+                    }), owned.signal);
+                    return respond(json(result, 200, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                    release();
+                }
+            }
+            if (route.kind === "workflow-status") {
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const record = await awaitWithSignal(getWorkflowRun(exposure.checkpoints, {
+                        workflowId: exposure.definition.id,
+                        runId: route.runId,
+                        ownership: authorization.ownership,
+                        signal: owned.signal,
+                    }), owned.signal);
+                    if (!record)
+                        throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                    return respond(json(record, 200, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                }
+            }
+            if (route.kind === "workflow-cancel") {
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const result = await awaitWithSignal(cancelWorkflowRun({
+                        workflowId: exposure.definition.id,
+                        runId: route.runId,
+                        checkpoints: exposure.checkpoints,
+                        ownership: authorization.ownership,
+                        signal: owned.signal,
+                    }), owned.signal);
+                    return respond(json(result, 200, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                }
+            }
+            if (route.kind === "workflow-resume") {
+                acquire();
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                    const result = await awaitWithSignal(resumeWorkflow(exposure.definition, {
+                        workflowId: exposure.definition.id,
+                        runId: route.runId,
+                    }, {
+                        ...exposure.runOptions,
+                        checkpoints: exposure.checkpoints,
+                        ownership: authorization.ownership,
+                        metadata: { ...exposure.runOptions?.metadata, ...authorization.metadata },
+                        redactor: options.redactor,
+                        signal: owned.signal,
+                        resume: readResume(body),
+                    }), owned.signal);
+                    return respond(json(result, 200, limits, options));
+                }
+                finally {
+                    owned.dispose();
+                    release();
+                }
+            }
+            acquire();
+            const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+            try {
+                const body = await readJsonObject(request, limits.maxRequestBytes, owned.signal);
+                const runId = readOptionalId(body.runId, "runId") ?? crypto.randomUUID();
+                const workflowOptions = {
+                    ...exposure.runOptions,
+                    checkpoints: exposure.checkpoints,
+                    ownership: authorization.ownership,
+                    metadata: { ...exposure.runOptions?.metadata, ...authorization.metadata },
+                    redactor: options.redactor,
+                    signal: owned.signal,
+                    runId,
+                };
+                if (route.kind === "workflow-run") {
+                    const result = await awaitWithSignal(runWorkflow(exposure.definition, body.input, workflowOptions), owned.signal);
+                    const response = respond(json(result, 200, limits, options));
+                    owned.dispose();
+                    release();
+                    return response;
+                }
+                const bus = createWorkflowEventBus({
+                    workflowId: exposure.definition.id,
+                    runId,
+                    maxQueuedEvents: limits.maxQueuedEvents,
+                    overflow: "close",
+                    signal: owned.signal,
+                });
+                const events = bus.subscribe();
+                void runWorkflow(exposure.definition, body.input, { ...workflowOptions, eventBus: bus })
+                    .catch(() => undefined)
+                    .finally(() => bus.close());
+                return respond(sse(events, owned, limits, options, release));
+            }
+            catch (error) {
+                owned.dispose();
+                release();
+                throw error;
+            }
+        }
+        catch (error) {
+            return respond(errorResponse(error, limits, options));
+        }
+    };
+    function acquire() {
+        if (activeRuns >= limits.maxConcurrentRuns) {
+            throw new PrismServerError("Server is busy", 429, "ERR_PRISM_SERVER_CONCURRENCY");
+        }
+        activeRuns += 1;
+    }
+    function release() {
+        activeRuns = Math.max(0, activeRuns - 1);
+    }
+}
+function parseRoute(request, base) {
+    const pathname = new URL(request.url).pathname;
+    if (pathname !== base && !pathname.startsWith(`${base}/`))
+        return undefined;
+    let parts;
+    try {
+        parts = pathname.slice(base.length).split("/").filter(Boolean).map(decodeURIComponent);
+    }
+    catch {
+        throw new PrismServerError("Invalid route", 400, "ERR_PRISM_SERVER_ROUTE");
+    }
+    const [group, id, segment, runId, action] = parts;
+    if (group === "schedules" && parts.length === 1 && request.method === "GET") {
+        return { kind: "schedule-list", operation: "schedule.list", capabilityId: "*" };
+    }
+    if (!id || !validId(id))
+        return undefined;
+    if (group === "schedules") {
+        if (parts.length === 2 && request.method === "POST")
+            return { kind: "schedule-create", operation: "schedule.create", capabilityId: id };
+        if (parts.length === 2 && request.method === "DELETE")
+            return { kind: "schedule-delete", operation: "schedule.delete", capabilityId: id };
+        if (parts.length === 3 && segment === "pause" && request.method === "POST")
+            return { kind: "schedule-pause", operation: "schedule.pause", capabilityId: id };
+        if (parts.length === 3 && segment === "resume" && request.method === "POST")
+            return { kind: "schedule-resume", operation: "schedule.resume", capabilityId: id };
+        if (parts.length === 3 && segment === "trigger" && request.method === "POST")
+            return { kind: "schedule-trigger", operation: "schedule.trigger", capabilityId: id };
+        return undefined;
+    }
+    if (group === "agents" && segment === "runs" && parts.length === 3 && request.method === "POST") {
+        return { kind: "agent-run", operation: "agent.run", capabilityId: id };
+    }
+    if (group === "agents" && segment === "stream" && parts.length === 3 && request.method === "POST") {
+        return { kind: "agent-stream", operation: "agent.stream", capabilityId: id };
+    }
+    if (group !== "workflows")
+        return undefined;
+    if (segment === "runs" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-run", operation: "workflow.run", capabilityId: id };
+    }
+    if (segment === "stream" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-stream", operation: "workflow.stream", capabilityId: id };
+    }
+    if (segment === "enqueue" && parts.length === 3 && request.method === "POST") {
+        return { kind: "workflow-enqueue", operation: "workflow.enqueue", capabilityId: id };
+    }
+    if (segment !== "runs" || !runId || !validId(runId))
+        return undefined;
+    if (parts.length === 4 && request.method === "GET") {
+        return { kind: "workflow-status", operation: "workflow.status", capabilityId: id, runId };
+    }
+    if (parts.length === 4 && request.method === "DELETE") {
+        return { kind: "workflow-cancel", operation: "workflow.cancel", capabilityId: id, runId };
+    }
+    if (parts.length === 5 && action === "resume" && request.method === "POST") {
+        return { kind: "workflow-resume", operation: "workflow.resume", capabilityId: id, runId };
+    }
+    if (parts.length === 5 && action === "replay" && request.method === "POST") {
+        return { kind: "workflow-replay", operation: "workflow.replay", capabilityId: id, runId };
+    }
+    return undefined;
+}
+async function authorize(options, request, operation, capabilityId, timeoutMs) {
+    let result;
+    let timeout;
+    const controller = new AbortController();
+    const abort = () => controller.abort(request.signal.reason);
+    if (request.signal.aborted)
+        abort();
+    else
+        request.signal.addEventListener("abort", abort, { once: true });
+    try {
+        result = await Promise.race([
+            options.authorize({ request, operation, capabilityId, signal: controller.signal }),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => {
+                    controller.abort(new Error("authorization timed out"));
+                    resolve(false);
+                }, timeoutMs);
+            }),
+        ]);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        request.signal.removeEventListener("abort", abort);
+    }
+    if (!result || !hasOwnership(result.ownership))
+        return false;
+    return result;
+}
+function hasOwnership(value) {
+    return [value.tenantId, value.accountId, value.userId].some((item) => typeof item === "string" && item.length > 0);
+}
+async function createSession(exposure, authorization) {
+    if ("sessionFactory" in exposure) {
+        return { session: await exposure.sessionFactory(authorization), runOptions: exposure.runOptions };
+    }
+    return { session: exposure.createSession() };
+}
+async function readJsonObject(request, maxBytes, signal) {
+    const type = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+    if (type !== "application/json")
+        throw new PrismServerError("Content-Type must be application/json", 415, "ERR_PRISM_SERVER_CONTENT_TYPE");
+    const declared = Number(request.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > maxBytes)
+        throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+    const reader = request.body?.getReader();
+    if (!reader)
+        throw new PrismServerError("JSON body is required", 400, "ERR_PRISM_SERVER_BODY");
+    const chunks = [];
+    let size = 0;
+    const abort = () => { void reader.cancel(signal.reason); };
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener("abort", abort, { once: true });
+    try {
+        while (true) {
+            const next = await reader.read();
+            if (next.done)
+                break;
+            size += next.value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel();
+                throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+            }
+            chunks.push(next.value);
+        }
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        reader.releaseLock();
+    }
+    if (signal.aborted)
+        throw new PrismServerError("Request timed out or disconnected", 408, "ERR_PRISM_SERVER_ABORTED");
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("object required");
+        return value;
+    }
+    catch (error) {
+        if (error instanceof PrismServerError)
+            throw error;
+        throw new PrismServerError("Invalid JSON object body", 400, "ERR_PRISM_SERVER_BODY");
+    }
+}
+function readAgentInput(value) {
+    if (typeof value === "string")
+        return value;
+    if (isMessage(value))
+        return value;
+    if (Array.isArray(value) && value.length > 0 && value.every(isMessage))
+        return value;
+    throw new PrismServerError("input must be a string, message, or non-empty message array", 400, "ERR_PRISM_SERVER_INPUT");
+}
+function isMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const item = value;
+    return ["system", "user", "assistant", "tool"].includes(String(item.role)) && Array.isArray(item.content);
+}
+function readResume(body) {
+    if (body.decision !== "approve" && body.decision !== "deny") {
+        throw new PrismServerError("decision must be approve or deny", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (!Number.isSafeInteger(body.expectedVersion) || Number(body.expectedVersion) < 1) {
+        throw new PrismServerError("expectedVersion must be a positive safe integer", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return { decision: body.decision, input: body.input, expectedVersion: Number(body.expectedVersion) };
+}
+function readRequiredString(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new PrismServerError(`${name} is required`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+function readRequiredId(value, name) {
+    const result = readOptionalId(value, name);
+    if (!result)
+        throw new PrismServerError(`${name} is required`, 400, "ERR_PRISM_SERVER_ID");
+    return result;
+}
+function readPositiveInteger(value, name) {
+    const number = typeof value === "string" ? Number(value) : value;
+    if (!Number.isSafeInteger(number) || Number(number) < 1)
+        throw new PrismServerError(`${name} must be a positive safe integer`, 400, "ERR_PRISM_SERVER_INPUT");
+    return Number(number);
+}
+function readOptionalObject(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PrismServerError(`${name} must be an object`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+function readScheduleStatus(value) {
+    if (value === null)
+        return undefined;
+    if (value === "active" || value === "paused" || value === "completed")
+        return value;
+    throw new PrismServerError("status is invalid", 400, "ERR_PRISM_SERVER_INPUT");
+}
+function sameOwnership(left, right) {
+    return left.tenantId === right.tenantId && left.accountId === right.accountId && left.userId === right.userId;
+}
+function readOptionalId(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !validId(value))
+        throw new PrismServerError(`${name} is invalid`, 400, "ERR_PRISM_SERVER_ID");
+    return value;
+}
+function validId(value) {
+    return value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+}
+function normalizeBasePath(value) {
+    if (!value.startsWith("/") || value.includes("?") || value.includes("#"))
+        throw new RangeError("basePath must be an absolute URL path");
+    const normalized = value.length > 1 ? value.replace(/\/+$/, "") : value;
+    if (normalized === "/")
+        throw new RangeError("basePath cannot expose the URL root");
+    return normalized;
+}
+function assertRequestPolicy(request, hosts, origins) {
+    if (hosts) {
+        const host = request.headers.get("host") ?? new URL(request.url).host;
+        if (!hosts.includes(host))
+            throw new PrismServerError("Forbidden host", 403, "ERR_PRISM_SERVER_HOST");
+    }
+    const origin = request.headers.get("origin");
+    if (origin && origins && !origins.includes(origin))
+        throw new PrismServerError("Forbidden origin", 403, "ERR_PRISM_SERVER_ORIGIN");
+}
+async function awaitWithSignal(promise, signal) {
+    if (signal.aborted)
+        throw new PrismServerError("Request timed out or disconnected", 408, "ERR_PRISM_SERVER_ABORTED");
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(new PrismServerError("Request timed out or disconnected", 408, "ERR_PRISM_SERVER_ABORTED"));
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    });
+}
+function ownedSignal(request, timeoutMs, disconnectAborts) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(request.signal.reason ?? new Error("request disconnected"));
+    if (disconnectAborts) {
+        if (request.signal.aborted)
+            abort();
+        else
+            request.signal.addEventListener("abort", abort, { once: true });
+    }
+    const timeout = setTimeout(() => controller.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+    return {
+        signal: controller.signal,
+        abort: (reason) => controller.abort(reason),
+        dispose() {
+            clearTimeout(timeout);
+            request.signal.removeEventListener("abort", abort);
+        },
+    };
+}
+function sse(source, owned, limits, options, release) {
+    const iterator = source[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    let events = 0;
+    let bytes = 0;
+    let finished = false;
+    const onAbort = () => { void finish(owned.signal.reason); };
+    const finish = async (reason) => {
+        if (finished)
+            return;
+        finished = true;
+        owned.signal.removeEventListener("abort", onAbort);
+        owned.abort(reason);
+        owned.dispose();
+        release();
+        await iterator.return?.();
+    };
+    owned.signal.addEventListener("abort", onAbort, { once: true });
+    const stream = new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    await finish();
+                    controller.close();
+                    return;
+                }
+                const safe = options.redactor?.redact(next.value) ?? next.value;
+                const chunk = encoder.encode(`data: ${JSON.stringify(safe)}\n\n`);
+                events += 1;
+                bytes += chunk.byteLength;
+                if (chunk.byteLength > limits.maxEventBytes || events > limits.maxStreamEvents || bytes > limits.maxStreamBytes) {
+                    const error = encoder.encode('data: {"type":"error","error":{"code":"ERR_PRISM_SERVER_STREAM_LIMIT","message":"stream limit exceeded"}}\n\n');
+                    if (error.byteLength <= limits.maxEventBytes)
+                        controller.enqueue(error);
+                    await finish(new Error("stream limit exceeded"));
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(chunk);
+            }
+            catch {
+                const error = encoder.encode('data: {"type":"error","error":{"code":"ERR_PRISM_SERVER_STREAM","message":"stream failed"}}\n\n');
+                if (error.byteLength <= limits.maxEventBytes)
+                    controller.enqueue(error);
+                await finish(new Error("stream failed"));
+                controller.close();
+            }
+        },
+        cancel(reason) {
+            return finish(reason);
+        },
+    });
+    return new Response(stream, { status: 200, headers: SSE_HEADERS });
+}
+function json(value, status, limits, options) {
+    const safe = options.redactor?.redact(value) ?? value;
+    const text = JSON.stringify(safe);
+    if (text === undefined || new TextEncoder().encode(text).byteLength > limits.maxResponseBytes) {
+        throw new PrismServerError("Response too large", 507, "ERR_PRISM_SERVER_RESPONSE_LIMIT");
+    }
+    return new Response(text, { status, headers: JSON_HEADERS });
+}
+function errorResponse(error, limits, options) {
+    const workflowCode = error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+    const mapped = workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE_BUSY"
+        ? { status: 409, code: workflowCode, message: "Schedule is busy" }
+        : workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE"
+            ? { status: 400, code: workflowCode, message: error instanceof Error ? error.message : "Invalid schedule" }
+            : workflowCode === "ERR_PRISM_WORKFLOW_SCHEDULE_OWNERSHIP"
+                ? { status: 403, code: workflowCode, message: "Forbidden" }
+                : workflowCode === "ERR_PRISM_WORKFLOW_NOT_FOUND"
+                    ? { status: 404, code: workflowCode, message: "Not found" }
+                    : workflowCode === "ERR_PRISM_WORKFLOW_CHECKPOINT"
+                        ? { status: 409, code: workflowCode, message: "Workflow checkpoint operation rejected" }
+                        : undefined;
+    const known = error instanceof PrismServerError;
+    const status = mapped?.status ?? (known ? error.status : error instanceof DOMException && error.name === "AbortError" ? 499 : 500);
+    const code = mapped?.code ?? (known ? error.code : status === 499 ? "ERR_PRISM_SERVER_ABORTED" : "ERR_PRISM_SERVER_INTERNAL");
+    const message = mapped?.message ?? (known ? error.message : status === 499 ? "Request aborted" : "Internal server error");
+    try {
+        return json({ error: { code, message } }, status, limits, options);
+    }
+    catch {
+        return new Response(null, { status });
+    }
+}
+function addHeaders(response, extra) {
+    if (!extra)
+        return response;
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(extra))
+        headers.set(name, value);
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
+//# sourceMappingURL=handler.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createPrismHandler } from "./handler.js";
+export { DEFAULT_MAX_REQUEST_BYTES, HARD_MAX_REQUEST_BYTES, DEFAULT_MAX_RESPONSE_BYTES, HARD_MAX_RESPONSE_BYTES, DEFAULT_MAX_EVENT_BYTES, HARD_MAX_EVENT_BYTES, DEFAULT_MAX_STREAM_BYTES, HARD_MAX_STREAM_BYTES, DEFAULT_MAX_STREAM_EVENTS, HARD_MAX_STREAM_EVENTS, DEFAULT_MAX_CONCURRENT_RUNS, HARD_MAX_CONCURRENT_RUNS, DEFAULT_MAX_QUEUED_EVENTS, HARD_MAX_QUEUED_EVENTS, DEFAULT_REQUEST_TIMEOUT_MS, HARD_REQUEST_TIMEOUT_MS, resolvePrismServerLimits, } from "./limits.js";
+export type { PrismServerLimits, ResolvedPrismServerLimits, } from "./limits.js";
+export type { PrismServerOperation, PrismServerAuthorization, PrismServerAuthorizationInput, PrismServerAuthorizer, PrismAgentExposure, PrismWorkflowExposure, PrismScheduleExposure, CreatePrismHandlerOptions, PrismRequestHandler, } from "./types.js";
+export { PrismServerError } from "./types.js";
+export declare const packageName = "@arnilo/prism-server";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { createPrismHandler } from "./handler.js";
+export { DEFAULT_MAX_REQUEST_BYTES, HARD_MAX_REQUEST_BYTES, DEFAULT_MAX_RESPONSE_BYTES, HARD_MAX_RESPONSE_BYTES, DEFAULT_MAX_EVENT_BYTES, HARD_MAX_EVENT_BYTES, DEFAULT_MAX_STREAM_BYTES, HARD_MAX_STREAM_BYTES, DEFAULT_MAX_STREAM_EVENTS, HARD_MAX_STREAM_EVENTS, DEFAULT_MAX_CONCURRENT_RUNS, HARD_MAX_CONCURRENT_RUNS, DEFAULT_MAX_QUEUED_EVENTS, HARD_MAX_QUEUED_EVENTS, DEFAULT_REQUEST_TIMEOUT_MS, HARD_REQUEST_TIMEOUT_MS, resolvePrismServerLimits, } from "./limits.js";
+export { PrismServerError } from "./types.js";
+export const packageName = "@arnilo/prism-server";
+//# sourceMappingURL=index.js.map

package/dist/limits.d.ts

@@ -0,0 +1,37 @@
+export declare const DEFAULT_MAX_REQUEST_BYTES: number;
+export declare const HARD_MAX_REQUEST_BYTES: number;
+export declare const DEFAULT_MAX_RESPONSE_BYTES: number;
+export declare const HARD_MAX_RESPONSE_BYTES: number;
+export declare const DEFAULT_MAX_EVENT_BYTES: number;
+export declare const HARD_MAX_EVENT_BYTES: number;
+export declare const DEFAULT_MAX_STREAM_BYTES: number;
+export declare const HARD_MAX_STREAM_BYTES: number;
+export declare const DEFAULT_MAX_STREAM_EVENTS = 10000;
+export declare const HARD_MAX_STREAM_EVENTS = 100000;
+export declare const DEFAULT_MAX_CONCURRENT_RUNS = 16;
+export declare const HARD_MAX_CONCURRENT_RUNS = 256;
+export declare const DEFAULT_MAX_QUEUED_EVENTS = 128;
+export declare const HARD_MAX_QUEUED_EVENTS = 4096;
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 120000;
+export declare const HARD_REQUEST_TIMEOUT_MS: number;
+export interface PrismServerLimits {
+    readonly maxRequestBytes?: number;
+    readonly maxResponseBytes?: number;
+    readonly maxEventBytes?: number;
+    readonly maxStreamBytes?: number;
+    readonly maxStreamEvents?: number;
+    readonly maxConcurrentRuns?: number;
+    readonly maxQueuedEvents?: number;
+    readonly requestTimeoutMs?: number;
+}
+export interface ResolvedPrismServerLimits {
+    readonly maxRequestBytes: number;
+    readonly maxResponseBytes: number;
+    readonly maxEventBytes: number;
+    readonly maxStreamBytes: number;
+    readonly maxStreamEvents: number;
+    readonly maxConcurrentRuns: number;
+    readonly maxQueuedEvents: number;
+    readonly requestTimeoutMs: number;
+}
+export declare function resolvePrismServerLimits(input?: PrismServerLimits): ResolvedPrismServerLimits;

package/dist/limits.js

@@ -0,0 +1,36 @@
+export const DEFAULT_MAX_REQUEST_BYTES = 64 * 1024;
+export const HARD_MAX_REQUEST_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
+export const HARD_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+export const DEFAULT_MAX_EVENT_BYTES = 64 * 1024;
+export const HARD_MAX_EVENT_BYTES = 1024 * 1024;
+export const DEFAULT_MAX_STREAM_BYTES = 10 * 1024 * 1024;
+export const HARD_MAX_STREAM_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_STREAM_EVENTS = 10_000;
+export const HARD_MAX_STREAM_EVENTS = 100_000;
+export const DEFAULT_MAX_CONCURRENT_RUNS = 16;
+export const HARD_MAX_CONCURRENT_RUNS = 256;
+export const DEFAULT_MAX_QUEUED_EVENTS = 128;
+export const HARD_MAX_QUEUED_EVENTS = 4096;
+export const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
+export const HARD_REQUEST_TIMEOUT_MS = 30 * 60_000;
+export function resolvePrismServerLimits(input = {}) {
+    return {
+        maxRequestBytes: bounded(input.maxRequestBytes, DEFAULT_MAX_REQUEST_BYTES, HARD_MAX_REQUEST_BYTES, "maxRequestBytes"),
+        maxResponseBytes: bounded(input.maxResponseBytes, DEFAULT_MAX_RESPONSE_BYTES, HARD_MAX_RESPONSE_BYTES, "maxResponseBytes"),
+        maxEventBytes: bounded(input.maxEventBytes, DEFAULT_MAX_EVENT_BYTES, HARD_MAX_EVENT_BYTES, "maxEventBytes"),
+        maxStreamBytes: bounded(input.maxStreamBytes, DEFAULT_MAX_STREAM_BYTES, HARD_MAX_STREAM_BYTES, "maxStreamBytes"),
+        maxStreamEvents: bounded(input.maxStreamEvents, DEFAULT_MAX_STREAM_EVENTS, HARD_MAX_STREAM_EVENTS, "maxStreamEvents"),
+        maxConcurrentRuns: bounded(input.maxConcurrentRuns, DEFAULT_MAX_CONCURRENT_RUNS, HARD_MAX_CONCURRENT_RUNS, "maxConcurrentRuns"),
+        maxQueuedEvents: bounded(input.maxQueuedEvents, DEFAULT_MAX_QUEUED_EVENTS, HARD_MAX_QUEUED_EVENTS, "maxQueuedEvents"),
+        requestTimeoutMs: bounded(input.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, HARD_REQUEST_TIMEOUT_MS, "requestTimeoutMs"),
+    };
+}
+function bounded(value, fallback, cap, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > cap) {
+        throw new RangeError(`${name} must be a positive safe integer <= ${cap}`);
+    }
+    return resolved;
+}
+//# sourceMappingURL=limits.js.map

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+import type { Agent, AgentSession, OwnershipScope, RunOptions, SecretRedactor } from "@arnilo/prism";
+import type { RunWorkflowOptions, WorkflowCheckpointAdapter, WorkflowDefinition, WorkflowSchedules } from "@arnilo/prism-workflows";
+import type { PrismServerLimits } from "./limits.js";
+export type PrismServerOperation = "agent.run" | "agent.stream" | "workflow.run" | "workflow.stream" | "workflow.status" | "workflow.cancel" | "workflow.resume" | "workflow.enqueue" | "workflow.replay" | "schedule.create" | "schedule.list" | "schedule.pause" | "schedule.resume" | "schedule.trigger" | "schedule.delete";
+export interface PrismServerAuthorization {
+    readonly ownership: OwnershipScope;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface PrismServerAuthorizationInput {
+    readonly request: Request;
+    readonly operation: PrismServerOperation;
+    readonly capabilityId: string;
+    readonly signal: AbortSignal;
+}
+export type PrismServerAuthorizer = (input: PrismServerAuthorizationInput) => false | PrismServerAuthorization | Promise<false | PrismServerAuthorization>;
+export interface PrismAgentExposure {
+    readonly sessionFactory: (authorization: PrismServerAuthorization) => AgentSession | Promise<AgentSession>;
+    readonly runOptions?: Omit<RunOptions, "ownership" | "signal" | "redactor">;
+}
+export interface PrismWorkflowExposure {
+    readonly definition: WorkflowDefinition;
+    readonly checkpoints: WorkflowCheckpointAdapter;
+    readonly runOptions?: Omit<RunWorkflowOptions, "checkpoints" | "ownership" | "signal" | "redactor" | "eventBus" | "runId">;
+}
+export type PrismScheduleExposure = WorkflowSchedules | ((authorization: PrismServerAuthorization, signal: AbortSignal) => WorkflowSchedules | Promise<WorkflowSchedules>);
+export interface CreatePrismHandlerOptions {
+    readonly agents?: Readonly<Record<string, Agent | PrismAgentExposure>>;
+    readonly workflows?: Readonly<Record<string, PrismWorkflowExposure>>;
+    readonly schedules?: PrismScheduleExposure;
+    readonly authorize: PrismServerAuthorizer;
+    readonly basePath?: string;
+    readonly allowedHosts?: readonly string[];
+    readonly allowedOrigins?: readonly string[];
+    readonly redactor?: SecretRedactor;
+    readonly limits?: PrismServerLimits;
+    readonly disconnectAborts?: boolean;
+}
+export type PrismRequestHandler = (request: Request) => Promise<Response>;
+export declare class PrismServerError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status?: number, code?: string);
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+export class PrismServerError extends Error {
+    status;
+    code;
+    constructor(message, status = 500, code = "ERR_PRISM_SERVER") {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "PrismServerError";
+    }
+}
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@arnilo/prism-server",
+  "version": "0.0.5",
+  "description": "Optional framework-free Web Request-to-Response handler for explicitly selected Prism agents and workflows.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/__tests__/*.test.js",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@arnilo/prism": "0.0.5",
+    "@arnilo/prism-workflows": "0.0.5"
+  },
+  "devDependencies": {
+    "@arnilo/prism": "file:../..",
+    "@arnilo/prism-workflows": "file:../workflows"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git",
+    "directory": "packages/server"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism/tree/main/packages/server#readme",
+  "keywords": [
+    "prism",
+    "server",
+    "fetch",
+    "agent",
+    "workflow"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}