@arnilo/prism-server 0.0.96 → 0.1.1

package/dist/drain.js

@@ -0,0 +1,57 @@
+import { DEFAULT_DRAIN_DEADLINE_MS, HARD_DRAIN_DEADLINE_MS, resolvePrismDeploymentLimits } from "./limits.js";
+import { PrismServerError } from "./types.js";
+export function createPrismDrainController(options = {}) {
+    const defaults = resolvePrismDeploymentLimits({ drainDeadlineMs: options.deadlineMs });
+    let draining = false;
+    let startedAt;
+    let deadlineAt;
+    let deadlineMs = defaults.drainDeadlineMs;
+    return {
+        get isDraining() {
+            return draining;
+        },
+        beginDrain(input) {
+            if (!draining) {
+                draining = true;
+                startedAt = new Date().toISOString();
+                deadlineMs = resolveDeadline(input?.deadlineMs ?? options.deadlineMs ?? DEFAULT_DRAIN_DEADLINE_MS);
+                deadlineAt = new Date(Date.now() + deadlineMs).toISOString();
+            }
+            return this.snapshot();
+        },
+        assertAdmit() {
+            if (draining) {
+                throw new PrismServerError("Server is draining", 503, "ERR_PRISM_SERVER_DRAINING");
+            }
+        },
+        snapshot() {
+            return {
+                status: draining ? "draining" : "serving",
+                draining,
+                ...(startedAt === undefined ? {} : { startedAt }),
+                ...(deadlineAt === undefined ? {} : { deadlineAt }),
+                deadlineMs,
+            };
+        },
+    };
+}
+function resolveDeadline(value) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > HARD_DRAIN_DEADLINE_MS) {
+        throw new RangeError(`drainDeadlineMs must be a positive safe integer <= ${HARD_DRAIN_DEADLINE_MS}`);
+    }
+    return value;
+}
+/** Operations that create or continue work; blocked during drain. Status/cancel/list remain open. */
+export function isAdmitOperation(operation) {
+    return (operation === "agent.run" ||
+        operation === "agent.stream" ||
+        operation === "agent.resume" ||
+        operation === "workflow.run" ||
+        operation === "workflow.stream" ||
+        operation === "workflow.enqueue" ||
+        operation === "workflow.resume" ||
+        operation === "workflow.replay" ||
+        operation === "schedule.create" ||
+        operation === "schedule.trigger");
+}
+//# sourceMappingURL=drain.js.map

package/dist/handler.js

@@ -1,5 +1,6 @@
-import { AgentRunStateError } from "@arnilo/prism";
+import { AgentRunStateError, assertIdentityActive, assertIdentityMatchesOwnership, HARD_MAX_DECISION_REASON_BYTES, HARD_MAX_ELICITATION_BYTES, HARD_MAX_PENDING_DECISIONS, } from "@arnilo/prism";
 import { cancelWorkflowRun, createWorkflowEventBus, enqueueWorkflow, getWorkflowRun, replayWorkflow, resumeWorkflow, runWorkflow, } from "@arnilo/prism-workflows";
+import { isAdmitOperation } from "./drain.js";
 import { resolvePrismServerLimits } from "./limits.js";
 import { PrismServerError } from "./types.js";
 const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
@@ -14,9 +15,7 @@ export function createPrismHandler(options) {
     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 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);
@@ -29,7 +28,7 @@ export function createPrismHandler(options) {
                     headers: {
                         "access-control-allow-origin": origin,
                         "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
-                        "access-control-allow-headers": "content-type, authorization",
+                        "access-control-allow-headers": "content-type, authorization, last-event-id",
                         vary: "origin",
                     },
                 }));
@@ -39,6 +38,24 @@ export function createPrismHandler(options) {
             const authorization = await authorize(options, request, route.operation, route.capabilityId, limits.requestTimeoutMs);
             if (!authorization)
                 throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+            if (options.rateLimit) {
+                const decision = await options.rateLimit({
+                    request,
+                    operation: route.operation,
+                    capabilityId: route.capabilityId,
+                    authorization,
+                    signal: request.signal,
+                });
+                if (decision !== true) {
+                    const headers = {};
+                    if (decision.retryAfterMs !== undefined && Number.isSafeInteger(decision.retryAfterMs) && decision.retryAfterMs > 0) {
+                        headers["retry-after"] = String(Math.ceil(decision.retryAfterMs / 1000));
+                    }
+                    throw new PrismServerError(decision.message ?? "Rate limit exceeded", 429, decision.code ?? "ERR_PRISM_SERVER_RATE_LIMIT", Object.keys(headers).length ? headers : undefined);
+                }
+            }
+            if (options.drain && isAdmitOperation(route.operation))
+                options.drain.assertAdmit();
             if (route.kind.startsWith("schedule-")) {
                 const selectedSchedules = options.schedules;
                 if (!selectedSchedules)
@@ -94,6 +111,35 @@ export function createPrismHandler(options) {
                     owned.dispose();
                 }
             }
+            if (route.kind === "agent-events") {
+                const exposure = options.agents?.[route.capabilityId];
+                if (!exposure || !("sessionFactory" in exposure) || !exposure.events || !exposure.resolveRun) {
+                    throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                }
+                if (!authorization.ownership.tenantId)
+                    throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+                acquire();
+                const owned = ownedSignal(request, limits.requestTimeoutMs, options.disconnectAborts ?? true);
+                try {
+                    const run = await awaitWithSignal(Promise.resolve(exposure.resolveRun({ runId: route.runId, authorization, signal: owned.signal })), owned.signal);
+                    if (!run?.sessionId)
+                        throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+                    const after = replayCursor(request, limits.maxReplayCursorBytes);
+                    const events = exposure.events.subscribe({
+                        ownership: authorization.ownership,
+                        sessionId: run.sessionId,
+                        runId: run.runId,
+                        after,
+                        signal: owned.signal,
+                    });
+                    return respond(sseAgentEvents(events, owned, limits, options, release));
+                }
+                catch (error) {
+                    owned.dispose();
+                    release();
+                    throw error;
+                }
+            }
             if (route.kind === "agent-status" || route.kind === "agent-resume") {
                 const exposure = options.agentRuns?.[route.capabilityId];
                 if (!exposure)
@@ -139,6 +185,7 @@ export function createPrismHandler(options) {
                     const runConfig = {
                         ...runOptions,
                         ownership: authorization.ownership,
+                        identity: authorization.identity,
                         metadata: { ...runOptions?.metadata, ...authorization.metadata },
                         redactor: options.redactor,
                         signal: owned.signal,
@@ -360,6 +407,8 @@ function parseRoute(request, base) {
             return { kind: "agent-status", operation: "agent.status", capabilityId: id, runId };
         if (parts.length === 5 && action === "resume" && request.method === "POST")
             return { kind: "agent-resume", operation: "agent.resume", capabilityId: id, runId };
+        if (parts.length === 5 && action === "events" && request.method === "GET")
+            return { kind: "agent-events", operation: "agent.events", capabilityId: id, runId };
     }
     if (group !== "workflows")
         return undefined;
@@ -418,6 +467,15 @@ async function authorize(options, request, operation, capabilityId, timeoutMs) {
     }
     if (!result || !hasOwnership(result.ownership))
         return false;
+    if (result.identity) {
+        try {
+            assertIdentityActive(result.identity);
+            assertIdentityMatchesOwnership(result.identity, result.ownership);
+        }
+        catch {
+            return false;
+        }
+    }
     return result;
 }
 function hasOwnership(value) {
@@ -441,7 +499,9 @@ async function readJsonObject(request, maxBytes, signal) {
         throw new PrismServerError("JSON body is required", 400, "ERR_PRISM_SERVER_BODY");
     const chunks = [];
     let size = 0;
-    const abort = () => { void reader.cancel(signal.reason); };
+    const abort = () => {
+        void reader.cancel(signal.reason);
+    };
     if (signal.aborted)
         abort();
     else
@@ -498,17 +558,66 @@ function isMessage(value) {
     const item = value;
     return ["system", "user", "assistant", "tool"].includes(String(item.role)) && Array.isArray(item.content);
 }
+const RUN_DECISION_OUTCOMES = new Set(["allow_once", "allow_for_run", "reject_once", "reject_for_run"]);
+const RUN_DECISION_KEYS = new Set(["approvalId", "outcome", "reason", "modifiedArguments", "elicitation"]);
+/** Boundary validation for a client-supplied decision batch; core re-validates under CAS. */
+function readAgentDecisions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > HARD_MAX_PENDING_DECISIONS) {
+        throw new PrismServerError("decisions must be a non-empty bounded array", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return value.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new PrismServerError("decision entry must be an object", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        const row = entry;
+        if (Object.keys(row).some((key) => !RUN_DECISION_KEYS.has(key))) {
+            throw new PrismServerError("decision entry has unknown keys", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (typeof row.approvalId !== "string" || row.approvalId.length === 0 || row.approvalId.length > 128) {
+            throw new PrismServerError("decision approvalId is invalid", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (typeof row.outcome !== "string" || !RUN_DECISION_OUTCOMES.has(row.outcome)) {
+            throw new PrismServerError("decision outcome is invalid", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        if (row.reason !== undefined &&
+            (typeof row.reason !== "string" || Buffer.byteLength(row.reason, "utf8") > HARD_MAX_DECISION_REASON_BYTES)) {
+            throw new PrismServerError("decision reason exceeds limits", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        for (const key of ["modifiedArguments", "elicitation"]) {
+            const field = row[key];
+            if (field === undefined)
+                continue;
+            if (!field || typeof field !== "object" || Array.isArray(field)) {
+                throw new PrismServerError(`decision ${key} must be an object`, 400, "ERR_PRISM_SERVER_RESUME");
+            }
+            const text = JSON.stringify(field);
+            if (text === undefined || Buffer.byteLength(text, "utf8") > HARD_MAX_ELICITATION_BYTES) {
+                throw new PrismServerError(`decision ${key} exceeds limits`, 400, "ERR_PRISM_SERVER_RESUME");
+            }
+        }
+        return entry;
+    });
+}
 function readAgentResume(body) {
-    if (Object.keys(body).some((key) => key !== "decision" && key !== "expectedVersion")) {
+    if (Object.keys(body).some((key) => key !== "decision" && key !== "decisions" && key !== "expectedVersion")) {
         throw new PrismServerError("Invalid agent resume body", 400, "ERR_PRISM_SERVER_RESUME");
     }
-    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, expectedVersion: Number(body.expectedVersion) };
+    if (body.decision !== undefined && body.decisions !== undefined) {
+        throw new PrismServerError("provide exactly one of decision or decisions", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    if (body.decision !== undefined) {
+        if (body.decision !== "approve" && body.decision !== "deny") {
+            throw new PrismServerError("decision must be approve or deny", 400, "ERR_PRISM_SERVER_RESUME");
+        }
+        return { decision: body.decision, expectedVersion: Number(body.expectedVersion) };
+    }
+    if (body.decisions === undefined) {
+        throw new PrismServerError("provide decision or decisions", 400, "ERR_PRISM_SERVER_RESUME");
+    }
+    return { decisions: readAgentDecisions(body.decisions), expectedVersion: Number(body.expectedVersion) };
 }
 function readResume(body) {
     if (body.decision !== "approve" && body.decision !== "deny") {
@@ -563,6 +672,18 @@ function readOptionalId(value, name) {
 function validId(value) {
     return value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
 }
+function replayCursor(request, maxBytes) {
+    const query = new URL(request.url).searchParams.get("cursor") ?? undefined;
+    const header = request.headers.get("last-event-id") ?? undefined;
+    if (query !== undefined && header !== undefined && query !== header) {
+        throw new PrismServerError("Conflicting event cursors", 400, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+    }
+    const cursor = header ?? query;
+    if (cursor !== undefined && (Buffer.byteLength(cursor, "utf8") > maxBytes || /\r|\n|\0/.test(cursor))) {
+        throw new PrismServerError("Invalid event cursor", 400, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+    }
+    return cursor;
+}
 function normalizeBasePath(value) {
     if (!value.startsWith("/") || value.includes("?") || value.includes("#"))
         throw new RangeError("basePath must be an absolute URL path");
@@ -609,13 +730,27 @@ function ownedSignal(request, timeoutMs, disconnectAborts) {
         },
     };
 }
+function sseAgentEvents(source, owned, limits, options, release) {
+    return sseStream(source, ({ record, cursor }) => {
+        if (/\r|\n|\0/.test(cursor) || Buffer.byteLength(cursor, "utf8") > limits.maxReplayCursorBytes) {
+            throw new PrismServerError("Invalid event cursor", 500, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+        }
+        const safe = options.redactor?.redact(record.event) ?? record.event;
+        return `id: ${cursor}\ndata: ${JSON.stringify(safe)}\n\n`;
+    }, owned, limits, release);
+}
 function sse(source, owned, limits, options, release) {
+    return sseStream(source, (value) => `data: ${JSON.stringify(options.redactor?.redact(value) ?? value)}\n\n`, owned, limits, release);
+}
+function sseStream(source, serialize, owned, limits, 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 onAbort = () => {
+        void finish(owned.signal.reason);
+    };
     const finish = async (reason) => {
         if (finished)
             return;
@@ -636,8 +771,7 @@ function sse(source, owned, limits, options, release) {
                     controller.close();
                     return;
                 }
-                const safe = options.redactor?.redact(next.value) ?? next.value;
-                const chunk = encoder.encode(`data: ${JSON.stringify(safe)}\n\n`);
+                const chunk = encoder.encode(serialize(next.value));
                 events += 1;
                 bytes += chunk.byteLength;
                 if (chunk.byteLength > limits.maxEventBytes || events > limits.maxStreamEvents || bytes > limits.maxStreamBytes) {
@@ -673,9 +807,7 @@ function json(value, status, limits, options) {
     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 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"
@@ -690,10 +822,20 @@ function errorResponse(error, limits, options) {
     const known = error instanceof PrismServerError;
     const agentState = error instanceof AgentRunStateError;
     const status = mapped?.status ?? (agentState ? 404 : known ? error.status : error instanceof DOMException && error.name === "AbortError" ? 499 : 500);
-    const code = mapped?.code ?? (agentState ? "ERR_PRISM_SERVER_NOT_FOUND" : known ? error.code : status === 499 ? "ERR_PRISM_SERVER_ABORTED" : "ERR_PRISM_SERVER_INTERNAL");
+    const code = mapped?.code ??
+        (agentState
+            ? "ERR_PRISM_SERVER_NOT_FOUND"
+            : known
+                ? error.code
+                : status === 499
+                    ? "ERR_PRISM_SERVER_ABORTED"
+                    : "ERR_PRISM_SERVER_INTERNAL");
     const message = mapped?.message ?? (agentState ? "Not found" : known ? error.message : status === 499 ? "Request aborted" : "Internal server error");
     try {
-        return json({ error: { code, message } }, status, limits, options);
+        const response = json({ error: { code, message } }, status, limits, options);
+        if (known && error.headers)
+            return addHeaders(response, error.headers);
+        return response;
     }
     catch {
         return new Response(null, { status });

package/dist/health.d.ts

@@ -0,0 +1,20 @@
+import type { PrismDrainController } from "./drain.js";
+import { type PrismDeploymentLimits } from "./limits.js";
+import { type PrismRequestHandler } from "./types.js";
+export interface CreatePrismHealthHandlerOptions {
+    /** Path prefix. Default `/health`. Routes: `/livez`, `/readyz`, and prefix itself. */
+    readonly basePath?: string;
+    /** Liveness probe. Default always true. Must stay O(1)/bounded. */
+    readonly live?: () => boolean | Promise<boolean>;
+    /** Readiness probe (deps). Default true. Must stay O(1)/bounded. */
+    readonly ready?: () => boolean | Promise<boolean>;
+    readonly drain?: PrismDrainController;
+    /**
+     * Optional extra fields for `?detail=1`. Never include secrets/tenant payloads.
+     * Emitted only when `authorizeDetail` returns true.
+     */
+    readonly detail?: () => Readonly<Record<string, unknown>> | Promise<Readonly<Record<string, unknown>>>;
+    readonly authorizeDetail?: (request: Request) => boolean | Promise<boolean>;
+    readonly limits?: PrismDeploymentLimits;
+}
+export declare function createPrismHealthHandler(options?: CreatePrismHealthHandlerOptions): PrismRequestHandler;

package/dist/health.js

@@ -0,0 +1,103 @@
+import { resolvePrismDeploymentLimits } from "./limits.js";
+import { PrismServerError } from "./types.js";
+const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
+export function createPrismHealthHandler(options = {}) {
+    const limits = resolvePrismDeploymentLimits(options.limits);
+    const base = normalizeHealthBase(options.basePath ?? "/health");
+    return async (request) => {
+        try {
+            if (request.method !== "GET" && request.method !== "HEAD") {
+                throw new PrismServerError("Method not allowed", 405, "ERR_PRISM_SERVER_METHOD");
+            }
+            const url = new URL(request.url);
+            const path = url.pathname.replace(/\/+$/, "") || "/";
+            const livePath = `${base}/livez`;
+            const readyPath = `${base}/readyz`;
+            if (path !== base && path !== livePath && path !== readyPath) {
+                throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+            }
+            const wantDetail = url.searchParams.get("detail") === "1";
+            if (wantDetail) {
+                const allowed = options.authorizeDetail ? await options.authorizeDetail(request) : false;
+                if (!allowed)
+                    throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+            }
+            const live = options.live ? await options.live() : true;
+            const readyCheck = options.ready ? await options.ready() : true;
+            const drainSnap = options.drain?.snapshot();
+            const draining = drainSnap?.draining === true;
+            const ready = readyCheck && !draining;
+            if (path === livePath) {
+                return healthJson({ status: live ? "ok" : "fail", live }, live ? 200 : 503, limits, request.method);
+            }
+            if (path === readyPath) {
+                return healthJson({
+                    status: ready ? "ok" : "fail",
+                    ready,
+                    ...(drainSnap ? { draining: drainSnap.draining } : {}),
+                }, ready ? 200 : 503, limits, request.method);
+            }
+            const body = {
+                status: live && ready ? "ok" : "fail",
+                live,
+                ready,
+            };
+            if (drainSnap) {
+                body.drain = {
+                    status: drainSnap.status,
+                    draining: drainSnap.draining,
+                    ...(drainSnap.deadlineAt === undefined ? {} : { deadlineAt: drainSnap.deadlineAt }),
+                };
+            }
+            if (wantDetail && options.detail) {
+                const extra = await options.detail();
+                assertSafeDetail(extra);
+                body.detail = extra;
+            }
+            const ok = live && ready;
+            return healthJson(body, ok ? 200 : 503, limits, request.method);
+        }
+        catch (error) {
+            if (error instanceof PrismServerError) {
+                return new Response(JSON.stringify({ error: { code: error.code, message: error.message } }), {
+                    status: error.status,
+                    headers: JSON_HEADERS,
+                });
+            }
+            return new Response(JSON.stringify({ error: { code: "ERR_PRISM_SERVER", message: "Health check failed" } }), {
+                status: 500,
+                headers: JSON_HEADERS,
+            });
+        }
+    };
+}
+function healthJson(body, status, limits, method) {
+    const text = JSON.stringify(body);
+    if (Buffer.byteLength(text, "utf8") > limits.maxHealthBytes) {
+        throw new PrismServerError("Health response too large", 507, "ERR_PRISM_SERVER_HEALTH_LIMIT");
+    }
+    if (method === "HEAD")
+        return new Response(null, { status, headers: JSON_HEADERS });
+    return new Response(text, { status, headers: JSON_HEADERS });
+}
+function normalizeHealthBase(basePath) {
+    if (!basePath.startsWith("/") || basePath.includes("?") || basePath.includes("#")) {
+        throw new PrismServerError("Invalid health basePath", 500, "ERR_PRISM_SERVER_CONFIG");
+    }
+    return basePath.replace(/\/+$/, "") || "/health";
+}
+function assertSafeDetail(value) {
+    for (const key of Object.keys(value)) {
+        const lower = key.toLowerCase();
+        if (lower.includes("secret") ||
+            lower.includes("token") ||
+            lower.includes("password") ||
+            lower.includes("credential") ||
+            lower === "authorization" ||
+            lower === "prompt" ||
+            lower === "body") {
+            throw new PrismServerError("Health detail key not allowed", 500, "ERR_PRISM_SERVER_HEALTH_DETAIL");
+        }
+    }
+}
+//# sourceMappingURL=health.js.map

package/dist/index.d.ts

@@ -1,6 +1,20 @@
+export type { ArtifactAttachInput, ArtifactAuthorizationInput, ArtifactAuthorizer, ArtifactCompareInput, ArtifactCompareResult, ArtifactDecisionEvent, ArtifactDecisionInput, ArtifactDeliveryInput, ArtifactDeliveryResult, ArtifactLimits, ArtifactListInput, ArtifactOperation, ArtifactRefInput, ArtifactReviseInput, ArtifactService, ArtifactServiceInput, CreateArtifactHandlerOptions, CreateArtifactServiceOptions, ResolvedArtifactLimits, } from "./artifacts.js";
+export { createArtifactHandler, createArtifactService, DEFAULT_ARTIFACT_CITATION_BYTES, DEFAULT_ARTIFACT_CITATIONS, DEFAULT_ARTIFACT_HASH_BYTES, DEFAULT_ARTIFACT_LIST_PAGE_LIMIT, DEFAULT_ARTIFACT_MIME_BYTES, DEFAULT_ARTIFACT_NOTE_BYTES, DEFAULT_ARTIFACT_PREVIEW_BYTES, DEFAULT_ARTIFACT_RECORD_BYTES, DEFAULT_ARTIFACT_REQUEST_BYTES, DEFAULT_ARTIFACT_REVISIONS, DEFAULT_ARTIFACT_TITLE_BYTES, DEFAULT_ARTIFACT_URI_BYTES, DEFAULT_ARTIFACTS_PER_THREAD, DEFAULT_DELIVERY_LINK_TOKEN_BYTES, DEFAULT_DELIVERY_LINK_TTL_SECONDS, HARD_ARTIFACT_CITATION_BYTES, HARD_ARTIFACT_CITATIONS, HARD_ARTIFACT_HASH_BYTES, HARD_ARTIFACT_LIST_PAGE_LIMIT, HARD_ARTIFACT_MIME_BYTES, HARD_ARTIFACT_NOTE_BYTES, HARD_ARTIFACT_PREVIEW_BYTES, HARD_ARTIFACT_RECORD_BYTES, HARD_ARTIFACT_REQUEST_BYTES, HARD_ARTIFACT_REVISIONS, HARD_ARTIFACT_TITLE_BYTES, HARD_ARTIFACT_URI_BYTES, HARD_ARTIFACTS_PER_THREAD, HARD_DELIVERY_LINK_TOKEN_BYTES, HARD_DELIVERY_LINK_TTL_SECONDS, resolveArtifactLimits, signArtifactDeliveryLink, verifyArtifactDeliveryLink, } from "./artifacts.js";
+export type { ConversationAuthorizationInput, ConversationAuthorizer, ConversationBranchInput, ConversationContinueInput, ConversationCreateInput, ConversationExportInput, ConversationExportPage, ConversationLimits, ConversationListInput, ConversationOperation, ConversationRefInput, ConversationReplayInput, ConversationReplayPage, ConversationService, ConversationServiceInput, ConversationServiceStore, ConversationSessionFactoryInput, CreateConversationHandlerOptions, CreateConversationServiceOptions, ResolvedConversationLimits, } from "./conversations.js";
+export { createConversationHandler, createConversationService, DEFAULT_CONVERSATION_CURSOR_BYTES, DEFAULT_CONVERSATION_EXPORT_BYTES, DEFAULT_CONVERSATION_EXPORT_PAGES, DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES, DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT, DEFAULT_CONVERSATION_REQUEST_BYTES, DEFAULT_CONVERSATION_REQUEST_ID_BYTES, DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT, DEFAULT_CONVERSATION_TITLE_BYTES, HARD_CONVERSATION_CURSOR_BYTES, HARD_CONVERSATION_EXPORT_BYTES, HARD_CONVERSATION_EXPORT_PAGES, HARD_CONVERSATION_MAX_ACTIVE_BRANCHES, HARD_CONVERSATION_REPLAY_PAGE_LIMIT, HARD_CONVERSATION_REQUEST_BYTES, HARD_CONVERSATION_REQUEST_ID_BYTES, HARD_CONVERSATION_THREAD_PAGE_LIMIT, HARD_CONVERSATION_TITLE_BYTES, resolveConversationLimits, } from "./conversations.js";
+export type { PrismDeploymentLease, PrismDeploymentLeaseOptions } from "./deployment.js";
+export { createPrismDeploymentLease, PRISM_DEPLOYMENT_LEASE_NAMESPACE } from "./deployment.js";
+export type { PrismDrainController, PrismDrainControllerOptions, PrismDrainSnapshot } from "./drain.js";
+export { createPrismDrainController, isAdmitOperation } from "./drain.js";
 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, PrismAgentRunExposure, PrismWorkflowExposure, PrismScheduleExposure, CreatePrismHandlerOptions, PrismRequestHandler, } from "./types.js";
+export type { CreatePrismHealthHandlerOptions } from "./health.js";
+export { createPrismHealthHandler } from "./health.js";
+export type { PrismDeploymentLimits, PrismServerLimits, ResolvedPrismDeploymentLimits, ResolvedPrismServerLimits, } from "./limits.js";
+export { DEFAULT_DRAIN_DEADLINE_MS, DEFAULT_MAX_CONCURRENT_RUNS, DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_HEALTH_BYTES, DEFAULT_MAX_QUEUED_EVENTS, DEFAULT_MAX_REPLAY_CURSOR_BYTES, DEFAULT_MAX_REPLAY_EVENTS, DEFAULT_MAX_REQUEST_BYTES, DEFAULT_MAX_RESPONSE_BYTES, DEFAULT_MAX_STREAM_BYTES, DEFAULT_MAX_STREAM_EVENTS, DEFAULT_REQUEST_TIMEOUT_MS, HARD_DRAIN_DEADLINE_MS, HARD_MAX_CONCURRENT_RUNS, HARD_MAX_EVENT_BYTES, HARD_MAX_HEALTH_BYTES, HARD_MAX_QUEUED_EVENTS, HARD_MAX_REPLAY_CURSOR_BYTES, HARD_MAX_REPLAY_EVENTS, HARD_MAX_REQUEST_BYTES, HARD_MAX_RESPONSE_BYTES, HARD_MAX_STREAM_BYTES, HARD_MAX_STREAM_EVENTS, HARD_REQUEST_TIMEOUT_MS, resolvePrismDeploymentLimits, resolvePrismServerLimits, } from "./limits.js";
+export type { MemoryRateLimiterOptions, PrismServerRateLimitDenial, PrismServerRateLimiter, PrismServerRateLimitInput, } from "./rate-limit.js";
+export { createMemoryRateLimiter } from "./rate-limit.js";
+export type { CreatePrismEventReplayOptions, CreatePrismReplayHandlerOptions, PrismAgentEventReplay, PrismEventReplay, PrismEventReplayRequest, } from "./replay.js";
+export { createPrismAgentEventReplay, createPrismEventReplay, createPrismReplayHandler } from "./replay.js";
+export type { CreatePrismHandlerOptions, PrismAgentEventResolutionInput, PrismAgentExposure, PrismAgentRunExposure, PrismRequestHandler, PrismScheduleExposure, PrismServerAuthorization, PrismServerAuthorizationInput, PrismServerAuthorizer, PrismServerOperation, PrismWorkflowExposure, } from "./types.js";
 export { PrismServerError } from "./types.js";
 export declare const packageName = "@arnilo/prism-server";

package/dist/index.js

@@ -1,5 +1,12 @@
+export { createArtifactHandler, createArtifactService, DEFAULT_ARTIFACT_CITATION_BYTES, DEFAULT_ARTIFACT_CITATIONS, DEFAULT_ARTIFACT_HASH_BYTES, DEFAULT_ARTIFACT_LIST_PAGE_LIMIT, DEFAULT_ARTIFACT_MIME_BYTES, DEFAULT_ARTIFACT_NOTE_BYTES, DEFAULT_ARTIFACT_PREVIEW_BYTES, DEFAULT_ARTIFACT_RECORD_BYTES, DEFAULT_ARTIFACT_REQUEST_BYTES, DEFAULT_ARTIFACT_REVISIONS, DEFAULT_ARTIFACT_TITLE_BYTES, DEFAULT_ARTIFACT_URI_BYTES, DEFAULT_ARTIFACTS_PER_THREAD, DEFAULT_DELIVERY_LINK_TOKEN_BYTES, DEFAULT_DELIVERY_LINK_TTL_SECONDS, HARD_ARTIFACT_CITATION_BYTES, HARD_ARTIFACT_CITATIONS, HARD_ARTIFACT_HASH_BYTES, HARD_ARTIFACT_LIST_PAGE_LIMIT, HARD_ARTIFACT_MIME_BYTES, HARD_ARTIFACT_NOTE_BYTES, HARD_ARTIFACT_PREVIEW_BYTES, HARD_ARTIFACT_RECORD_BYTES, HARD_ARTIFACT_REQUEST_BYTES, HARD_ARTIFACT_REVISIONS, HARD_ARTIFACT_TITLE_BYTES, HARD_ARTIFACT_URI_BYTES, HARD_ARTIFACTS_PER_THREAD, HARD_DELIVERY_LINK_TOKEN_BYTES, HARD_DELIVERY_LINK_TTL_SECONDS, resolveArtifactLimits, signArtifactDeliveryLink, verifyArtifactDeliveryLink, } from "./artifacts.js";
+export { createConversationHandler, createConversationService, DEFAULT_CONVERSATION_CURSOR_BYTES, DEFAULT_CONVERSATION_EXPORT_BYTES, DEFAULT_CONVERSATION_EXPORT_PAGES, DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES, DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT, DEFAULT_CONVERSATION_REQUEST_BYTES, DEFAULT_CONVERSATION_REQUEST_ID_BYTES, DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT, DEFAULT_CONVERSATION_TITLE_BYTES, HARD_CONVERSATION_CURSOR_BYTES, HARD_CONVERSATION_EXPORT_BYTES, HARD_CONVERSATION_EXPORT_PAGES, HARD_CONVERSATION_MAX_ACTIVE_BRANCHES, HARD_CONVERSATION_REPLAY_PAGE_LIMIT, HARD_CONVERSATION_REQUEST_BYTES, HARD_CONVERSATION_REQUEST_ID_BYTES, HARD_CONVERSATION_THREAD_PAGE_LIMIT, HARD_CONVERSATION_TITLE_BYTES, resolveConversationLimits, } from "./conversations.js";
+export { createPrismDeploymentLease, PRISM_DEPLOYMENT_LEASE_NAMESPACE } from "./deployment.js";
+export { createPrismDrainController, isAdmitOperation } from "./drain.js";
 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 { createPrismHealthHandler } from "./health.js";
+export { DEFAULT_DRAIN_DEADLINE_MS, DEFAULT_MAX_CONCURRENT_RUNS, DEFAULT_MAX_EVENT_BYTES, DEFAULT_MAX_HEALTH_BYTES, DEFAULT_MAX_QUEUED_EVENTS, DEFAULT_MAX_REPLAY_CURSOR_BYTES, DEFAULT_MAX_REPLAY_EVENTS, DEFAULT_MAX_REQUEST_BYTES, DEFAULT_MAX_RESPONSE_BYTES, DEFAULT_MAX_STREAM_BYTES, DEFAULT_MAX_STREAM_EVENTS, DEFAULT_REQUEST_TIMEOUT_MS, HARD_DRAIN_DEADLINE_MS, HARD_MAX_CONCURRENT_RUNS, HARD_MAX_EVENT_BYTES, HARD_MAX_HEALTH_BYTES, HARD_MAX_QUEUED_EVENTS, HARD_MAX_REPLAY_CURSOR_BYTES, HARD_MAX_REPLAY_EVENTS, HARD_MAX_REQUEST_BYTES, HARD_MAX_RESPONSE_BYTES, HARD_MAX_STREAM_BYTES, HARD_MAX_STREAM_EVENTS, HARD_REQUEST_TIMEOUT_MS, resolvePrismDeploymentLimits, resolvePrismServerLimits, } from "./limits.js";
+export { createMemoryRateLimiter } from "./rate-limit.js";
+export { createPrismAgentEventReplay, createPrismEventReplay, createPrismReplayHandler } from "./replay.js";
 export { PrismServerError } from "./types.js";
 export const packageName = "@arnilo/prism-server";
 //# sourceMappingURL=index.js.map

package/dist/limits.d.ts

@@ -14,6 +14,15 @@ 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;
+/** Phase 8 freeze: health body 4 KiB / 64 KiB; drain deadline 30 s / 5 min; replay page 100 / 500; cursor 4 / 16 KiB. */
+export declare const DEFAULT_MAX_HEALTH_BYTES: number;
+export declare const HARD_MAX_HEALTH_BYTES: number;
+export declare const DEFAULT_DRAIN_DEADLINE_MS = 30000;
+export declare const HARD_DRAIN_DEADLINE_MS: number;
+export declare const DEFAULT_MAX_REPLAY_EVENTS = 100;
+export declare const HARD_MAX_REPLAY_EVENTS = 500;
+export declare const DEFAULT_MAX_REPLAY_CURSOR_BYTES: number;
+export declare const HARD_MAX_REPLAY_CURSOR_BYTES: number;
 export interface PrismServerLimits {
     readonly maxRequestBytes?: number;
     readonly maxResponseBytes?: number;
@@ -22,6 +31,7 @@ export interface PrismServerLimits {
     readonly maxStreamEvents?: number;
     readonly maxConcurrentRuns?: number;
     readonly maxQueuedEvents?: number;
+    readonly maxReplayCursorBytes?: number;
     readonly requestTimeoutMs?: number;
 }
 export interface ResolvedPrismServerLimits {
@@ -32,6 +42,20 @@ export interface ResolvedPrismServerLimits {
     readonly maxStreamEvents: number;
     readonly maxConcurrentRuns: number;
     readonly maxQueuedEvents: number;
+    readonly maxReplayCursorBytes: number;
     readonly requestTimeoutMs: number;
 }
+export interface PrismDeploymentLimits {
+    readonly maxHealthBytes?: number;
+    readonly drainDeadlineMs?: number;
+    readonly maxReplayEvents?: number;
+    readonly maxReplayCursorBytes?: number;
+}
+export interface ResolvedPrismDeploymentLimits {
+    readonly maxHealthBytes: number;
+    readonly drainDeadlineMs: number;
+    readonly maxReplayEvents: number;
+    readonly maxReplayCursorBytes: number;
+}
 export declare function resolvePrismServerLimits(input?: PrismServerLimits): ResolvedPrismServerLimits;
+export declare function resolvePrismDeploymentLimits(input?: PrismDeploymentLimits): ResolvedPrismDeploymentLimits;

package/dist/limits.js

@@ -14,6 +14,15 @@ 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;
+/** Phase 8 freeze: health body 4 KiB / 64 KiB; drain deadline 30 s / 5 min; replay page 100 / 500; cursor 4 / 16 KiB. */
+export const DEFAULT_MAX_HEALTH_BYTES = 4 * 1024;
+export const HARD_MAX_HEALTH_BYTES = 64 * 1024;
+export const DEFAULT_DRAIN_DEADLINE_MS = 30_000;
+export const HARD_DRAIN_DEADLINE_MS = 5 * 60_000;
+export const DEFAULT_MAX_REPLAY_EVENTS = 100;
+export const HARD_MAX_REPLAY_EVENTS = 500;
+export const DEFAULT_MAX_REPLAY_CURSOR_BYTES = 4 * 1024;
+export const HARD_MAX_REPLAY_CURSOR_BYTES = 16 * 1024;
 export function resolvePrismServerLimits(input = {}) {
     return {
         maxRequestBytes: bounded(input.maxRequestBytes, DEFAULT_MAX_REQUEST_BYTES, HARD_MAX_REQUEST_BYTES, "maxRequestBytes"),
@@ -23,9 +32,18 @@ export function resolvePrismServerLimits(input = {}) {
         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"),
+        maxReplayCursorBytes: bounded(input.maxReplayCursorBytes, DEFAULT_MAX_REPLAY_CURSOR_BYTES, HARD_MAX_REPLAY_CURSOR_BYTES, "maxReplayCursorBytes"),
         requestTimeoutMs: bounded(input.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS, HARD_REQUEST_TIMEOUT_MS, "requestTimeoutMs"),
     };
 }
+export function resolvePrismDeploymentLimits(input = {}) {
+    return {
+        maxHealthBytes: bounded(input.maxHealthBytes, DEFAULT_MAX_HEALTH_BYTES, HARD_MAX_HEALTH_BYTES, "maxHealthBytes"),
+        drainDeadlineMs: bounded(input.drainDeadlineMs, DEFAULT_DRAIN_DEADLINE_MS, HARD_DRAIN_DEADLINE_MS, "drainDeadlineMs"),
+        maxReplayEvents: bounded(input.maxReplayEvents, DEFAULT_MAX_REPLAY_EVENTS, HARD_MAX_REPLAY_EVENTS, "maxReplayEvents"),
+        maxReplayCursorBytes: bounded(input.maxReplayCursorBytes, DEFAULT_MAX_REPLAY_CURSOR_BYTES, HARD_MAX_REPLAY_CURSOR_BYTES, "maxReplayCursorBytes"),
+    };
+}
 function bounded(value, fallback, cap, name) {
     const resolved = value ?? fallback;
     if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > cap) {

package/dist/rate-limit.d.ts

@@ -0,0 +1,26 @@
+import type { PrismServerAuthorization, PrismServerOperation } from "./types.js";
+export interface PrismServerRateLimitDenial {
+    readonly retryAfterMs?: number;
+    /** Attributable denial code for hosts/logs. Default ERR_PRISM_SERVER_RATE_LIMIT. */
+    readonly code?: string;
+    readonly message?: string;
+}
+export interface PrismServerRateLimitInput {
+    readonly request: Request;
+    readonly operation: PrismServerOperation;
+    readonly capabilityId: string;
+    readonly authorization: PrismServerAuthorization;
+    readonly signal: AbortSignal;
+}
+/** Return `true` to admit; return a denial object to short-circuit with 429. */
+export type PrismServerRateLimiter = (input: PrismServerRateLimitInput) => true | PrismServerRateLimitDenial | Promise<true | PrismServerRateLimitDenial>;
+export interface MemoryRateLimiterOptions {
+    readonly maxRequests: number;
+    readonly windowMs: number;
+    /** Default: identity tenant/account/user + operation. */
+    readonly key?: (input: PrismServerRateLimitInput) => string;
+    /** Cap distinct keys retained (oldest eviction). Default 1024. */
+    readonly maxKeys?: number;
+}
+/** Tiny in-memory sliding window for tests/single-process hosts. Not a distributed limiter. */
+export declare function createMemoryRateLimiter(options: MemoryRateLimiterOptions): PrismServerRateLimiter;