@arnilo/prism-server 0.0.13 → 0.0.15

package/dist/conversations.js

@@ -0,0 +1,552 @@
+import { randomUUID } from "node:crypto";
+import { CONVERSATION_METADATA_KEY, ConversationError, assertIdentityActive, assertIdentityMatchesOwnership, conversationMarkerMetadata, conversationThreadFromRecord, decodeConversationReplayCursor, encodeConversationReplayCursor, } from "@arnilo/prism";
+import { PrismServerError } from "./types.js";
+/** Phase 9 freeze: thread page 50/200; replay page 100/500; cursor 4/16 KiB; title 256 B/2 KiB;
+ *  request id 256 B/2 KiB; active branches 16/64; export 8/32 MiB and 100/500 pages; body 64 KiB/1 MiB. */
+export const DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT = 50;
+export const HARD_CONVERSATION_THREAD_PAGE_LIMIT = 200;
+export const DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT = 100;
+export const HARD_CONVERSATION_REPLAY_PAGE_LIMIT = 500;
+export const DEFAULT_CONVERSATION_CURSOR_BYTES = 4 * 1024;
+export const HARD_CONVERSATION_CURSOR_BYTES = 16 * 1024;
+export const DEFAULT_CONVERSATION_TITLE_BYTES = 256;
+export const HARD_CONVERSATION_TITLE_BYTES = 2 * 1024;
+export const DEFAULT_CONVERSATION_REQUEST_ID_BYTES = 256;
+export const HARD_CONVERSATION_REQUEST_ID_BYTES = 2 * 1024;
+export const DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES = 16;
+export const HARD_CONVERSATION_MAX_ACTIVE_BRANCHES = 64;
+export const DEFAULT_CONVERSATION_EXPORT_BYTES = 8 * 1024 * 1024;
+export const HARD_CONVERSATION_EXPORT_BYTES = 32 * 1024 * 1024;
+export const DEFAULT_CONVERSATION_EXPORT_PAGES = 100;
+export const HARD_CONVERSATION_EXPORT_PAGES = 500;
+export const DEFAULT_CONVERSATION_REQUEST_BYTES = 64 * 1024;
+export const HARD_CONVERSATION_REQUEST_BYTES = 1024 * 1024;
+export function resolveConversationLimits(input = {}) {
+    return {
+        threadPageLimit: bounded(input.threadPageLimit, DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT, HARD_CONVERSATION_THREAD_PAGE_LIMIT, "threadPageLimit"),
+        replayPageLimit: bounded(input.replayPageLimit, DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT, HARD_CONVERSATION_REPLAY_PAGE_LIMIT, "replayPageLimit"),
+        cursorBytes: bounded(input.cursorBytes, DEFAULT_CONVERSATION_CURSOR_BYTES, HARD_CONVERSATION_CURSOR_BYTES, "cursorBytes"),
+        titleBytes: bounded(input.titleBytes, DEFAULT_CONVERSATION_TITLE_BYTES, HARD_CONVERSATION_TITLE_BYTES, "titleBytes"),
+        requestIdBytes: bounded(input.requestIdBytes, DEFAULT_CONVERSATION_REQUEST_ID_BYTES, HARD_CONVERSATION_REQUEST_ID_BYTES, "requestIdBytes"),
+        maxActiveBranches: bounded(input.maxActiveBranches, DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES, HARD_CONVERSATION_MAX_ACTIVE_BRANCHES, "maxActiveBranches"),
+        exportBytes: bounded(input.exportBytes, DEFAULT_CONVERSATION_EXPORT_BYTES, HARD_CONVERSATION_EXPORT_BYTES, "exportBytes"),
+        exportPages: bounded(input.exportPages, DEFAULT_CONVERSATION_EXPORT_PAGES, HARD_CONVERSATION_EXPORT_PAGES, "exportPages"),
+        maxRequestBytes: bounded(input.maxRequestBytes, DEFAULT_CONVERSATION_REQUEST_BYTES, HARD_CONVERSATION_REQUEST_BYTES, "maxRequestBytes"),
+    };
+}
+// Explicit-candidate retention policy; candidates bypass policy discovery, holds still win.
+const CONVERSATION_DELETE_POLICY = {
+    id: "prism-conversation-delete",
+    name: "prism-conversation-delete",
+    createdAt: "1970-01-01T00:00:00.000Z",
+};
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+export function createConversationService(store, options) {
+    if (typeof store.appendSession !== "function") {
+        throw new RangeError("ConversationServiceStore requires appendSession (sqlite/postgres persistence)");
+    }
+    const appendSession = store.appendSession;
+    const limits = resolveConversationLimits(options.limits);
+    async function loadThread(input, threadId) {
+        assertOwnership(input.ownership);
+        input.signal?.throwIfAborted();
+        const page = await store.querySessions({ id: assertId(threadId, "threadId"), ...input.ownership, limit: 1 });
+        const thread = page.items[0] === undefined ? undefined : conversationThreadFromRecord(page.items[0]);
+        if (!thread)
+            throw new ConversationError("Conversation thread not found", "not_found");
+        return thread;
+    }
+    async function writeMarker(thread, marker) {
+        const now = new Date().toISOString();
+        await appendSession({
+            id: thread.id,
+            ...(thread.tenantId !== undefined ? { tenantId: thread.tenantId } : {}),
+            ...(thread.accountId !== undefined ? { accountId: thread.accountId } : {}),
+            ...(thread.userId !== undefined ? { userId: thread.userId } : {}),
+            createdAt: thread.createdAt,
+            updatedAt: now,
+            metadata: conversationMarkerMetadata(marker),
+        });
+    }
+    return {
+        async create(input) {
+            assertOwnership(input.ownership);
+            input.signal?.throwIfAborted();
+            if (input.identity)
+                assertIdentityMatchesOwnership(input.identity, input.ownership);
+            const id = input.id === undefined ? `conv_${randomUUID()}` : assertId(input.id, "id");
+            if (input.title !== undefined)
+                assertBytes(input.title, limits.titleBytes, "title_too_large");
+            if (input.requestId !== undefined)
+                assertBytes(input.requestId, limits.requestIdBytes, "request_id_too_large");
+            if (input.id !== undefined) {
+                // Idempotent get-or-create for explicit ids. ponytail: concurrent creates race to the
+                // last metadata write; both callers receive a thread and ownership is enforced on read.
+                const existing = await this.get({ ...input, threadId: id }).catch((error) => {
+                    if (error instanceof ConversationError && error.reason === "not_found")
+                        return undefined;
+                    throw error;
+                });
+                if (existing)
+                    return existing;
+            }
+            const now = new Date().toISOString();
+            await appendSession({
+                id,
+                ...input.ownership,
+                createdAt: now,
+                updatedAt: now,
+                metadata: conversationMarkerMetadata({
+                    ...(input.title === undefined ? {} : { title: input.title }),
+                    state: "active",
+                    ...(input.requestId === undefined ? {} : { requestId: input.requestId }),
+                    ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+                }),
+            });
+            return this.get({ ...input, threadId: id });
+        },
+        async list(input) {
+            assertOwnership(input.ownership);
+            input.signal?.throwIfAborted();
+            if (input.cursor !== undefined)
+                assertBytes(input.cursor, limits.cursorBytes, "cursor_too_large");
+            const limit = Math.min(input.limit ?? limits.threadPageLimit, limits.threadPageLimit);
+            if (!Number.isSafeInteger(limit) || limit < 1)
+                throw new ConversationError("limit is invalid", "invalid_input");
+            const page = await store.querySessions({
+                ...input.ownership,
+                metadataKey: CONVERSATION_METADATA_KEY,
+                cursor: input.cursor,
+                limit,
+                order: "desc",
+            });
+            const threads = page.items
+                .map((record) => conversationThreadFromRecord(record))
+                .filter((thread) => thread !== undefined);
+            if (page.nextCursor !== undefined)
+                assertBytes(page.nextCursor, limits.cursorBytes, "cursor_too_large");
+            return { items: threads, ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }) };
+        },
+        get(input) {
+            return loadThread(input, input.threadId);
+        },
+        async continue(input) {
+            const thread = await loadThread(input, input.threadId);
+            if (thread.state === "archived")
+                throw new ConversationError("Conversation thread is archived", "thread_archived");
+            const message = assertMessage(input.message);
+            if (input.requestId !== undefined)
+                assertBytes(input.requestId, limits.requestIdBytes, "request_id_too_large");
+            if (input.leafId !== undefined) {
+                assertId(input.leafId, "leafId");
+                if (!thread.branches.some((branch) => branch.leafId === input.leafId)) {
+                    throw new ConversationError("leafId is not a recorded branch of this thread", "unknown_branch");
+                }
+            }
+            const session = await options.sessionFactory({
+                thread,
+                ownership: input.ownership,
+                ...(input.leafId === undefined ? {} : { leafId: input.leafId }),
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            return session.run(message, {
+                ...options.runOptions,
+                ownership: input.ownership,
+                ...(input.identity === undefined ? {} : { identity: input.identity }),
+                redactor: options.redactor,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+                ...(input.requestId === undefined ? {} : { idempotencyKey: input.requestId }),
+                metadata: { ...options.runOptions?.metadata, conversationThreadId: thread.id },
+            });
+        },
+        async branch(input) {
+            const thread = await loadThread(input, input.threadId);
+            if (thread.state === "archived")
+                throw new ConversationError("Conversation thread is archived", "thread_archived");
+            const leafId = assertId(input.leafId, "leafId");
+            if (thread.branches.some((branch) => branch.leafId === leafId))
+                return thread;
+            if (thread.branches.length >= limits.maxActiveBranches) {
+                throw new ConversationError("Too many active branches for this thread", "too_many_branches");
+            }
+            // ponytail: read-modify-write of branch refs; concurrent branch calls can lose a ref, so
+            // the cap is approximate and the entry tree remains the content source of truth.
+            await writeMarker(thread, {
+                ...(thread.title === undefined ? {} : { title: thread.title }),
+                state: thread.state,
+                branches: [...thread.branches, { leafId, createdAt: new Date().toISOString() }],
+                ...(thread.metadata === undefined ? {} : { metadata: thread.metadata }),
+            });
+            return loadThread(input, thread.id);
+        },
+        async archive(input) {
+            const thread = await loadThread(input, input.threadId);
+            if (thread.state === "archived")
+                return thread;
+            await writeMarker(thread, {
+                ...(thread.title === undefined ? {} : { title: thread.title }),
+                state: "archived",
+                ...(thread.branches.length === 0 ? {} : { branches: thread.branches }),
+                ...(thread.metadata === undefined ? {} : { metadata: thread.metadata }),
+            });
+            return loadThread(input, thread.id);
+        },
+        async export(input) {
+            const thread = await loadThread(input, input.threadId);
+            const start = input.cursor === undefined
+                ? undefined
+                : decodeConversationReplayCursor(input.cursor, thread.id, limits.cursorBytes).cursor;
+            const events = [];
+            let bytes = 0;
+            let pages = 0;
+            let truncated = false;
+            let resumeCursor = start;
+            let nextCursor;
+            while (true) {
+                input.signal?.throwIfAborted();
+                const pageCursor = resumeCursor;
+                const page = await store.queryEvents({
+                    sessionId: thread.id,
+                    ...input.ownership,
+                    ...(pageCursor === undefined ? {} : { cursor: pageCursor }),
+                    limit: limits.replayPageLimit,
+                    order: "asc",
+                    redacted: true,
+                });
+                // Rows from runs without a redactor are never served (fail-closed skip, not throw).
+                const records = page.items.filter((record) => record.redacted);
+                const pageBytes = records.reduce((sum, record) => sum + Buffer.byteLength(JSON.stringify(record), "utf8"), 0);
+                // Page-granular byte backstop: stop before a page that would exceed the cap and hand
+                // back the cursor to that page. ponytail: a single page larger than exportBytes cannot
+                // be exported (no finer store cursor exists); raise exportBytes or stream via replay.
+                if (bytes + pageBytes > limits.exportBytes && (bytes > 0 || pageCursor !== undefined)) {
+                    truncated = true;
+                    nextCursor = pageCursor;
+                    break;
+                }
+                events.push(...records);
+                bytes += pageBytes;
+                pages += 1;
+                if (page.nextCursor === undefined)
+                    break;
+                if (pages >= limits.exportPages) {
+                    truncated = true;
+                    nextCursor = page.nextCursor;
+                    break;
+                }
+                resumeCursor = page.nextCursor;
+            }
+            return {
+                thread,
+                events: options.redactor.redact(events),
+                ...(nextCursor === undefined ? {} : { nextCursor: encodeConversationReplayCursor({ v: 1, threadId: thread.id, cursor: nextCursor }) }),
+                truncated,
+            };
+        },
+        async delete(input) {
+            const thread = await loadThread(input, input.threadId);
+            if (!store.lifecycle)
+                throw new ConversationError("Store does not support conversation deletion", "unsupported");
+            // Lifecycle purges the whole session ledger (entries, runs, events, tool calls, usage,
+            // branches, search rows) under legal-hold protection; holds always win over deletion.
+            const result = await store.lifecycle.applyRetention({
+                policy: CONVERSATION_DELETE_POLICY,
+                candidates: [thread.id],
+                ...input.ownership,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            return {
+                deleted: result.deleted.includes(thread.id),
+                held: result.skippedHeld.includes(thread.id),
+            };
+        },
+        async replay(input) {
+            const thread = await loadThread(input, input.threadId);
+            const inner = input.cursor === undefined
+                ? undefined
+                : decodeConversationReplayCursor(input.cursor, thread.id, limits.cursorBytes).cursor;
+            const limit = Math.min(input.limit ?? limits.replayPageLimit, limits.replayPageLimit);
+            if (!Number.isSafeInteger(limit) || limit < 1)
+                throw new ConversationError("limit is invalid", "invalid_input");
+            const page = await store.queryEvents({
+                sessionId: thread.id,
+                ...input.ownership,
+                ...(inner === undefined ? {} : { cursor: inner }),
+                limit,
+                order: "asc",
+                redacted: true,
+            });
+            if (page.items.length > limit)
+                throw new ConversationError("Replay page exceeds limit", "limit_exceeded");
+            const records = page.items.filter((record) => record.redacted);
+            const terminal = records.some((record) => record.event.type === "agent_finished" || record.event.type === "agent_denied" || record.event.type === "error");
+            if (page.nextCursor !== undefined)
+                assertBytes(page.nextCursor, limits.cursorBytes, "cursor_too_large");
+            return {
+                records,
+                ...(page.nextCursor === undefined ? {} : { nextCursor: encodeConversationReplayCursor({ v: 1, threadId: thread.id, cursor: page.nextCursor }) }),
+                terminal,
+            };
+        },
+    };
+}
+const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
+/** Framework-free HTTP adapter for one mounted conversation service (default base `/prism/conversations`). */
+export function createConversationHandler(options) {
+    const base = normalizeBasePath(options.basePath ?? "/prism/conversations");
+    const limits = resolveConversationLimits(options.limits);
+    return async (request) => {
+        try {
+            const route = parseConversationRoute(request, base);
+            if (!route)
+                throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+            const authorization = await options.authorize({
+                request,
+                operation: route.operation,
+                ...(route.threadId === undefined ? {} : { threadId: route.threadId }),
+                signal: request.signal,
+            });
+            if (!authorization)
+                throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+            if (authorization.identity) {
+                assertIdentityActive(authorization.identity);
+                assertIdentityMatchesOwnership(authorization.identity, authorization.ownership);
+            }
+            const input = {
+                ownership: authorization.ownership,
+                ...(authorization.identity === undefined ? {} : { identity: authorization.identity }),
+                signal: request.signal,
+            };
+            const service = options.service;
+            switch (route.kind) {
+                case "create": {
+                    const body = await readBody(request, limits.maxRequestBytes);
+                    const thread = await service.create({
+                        ...input,
+                        ...(body.id === undefined ? {} : { id: readString(body.id, "id") }),
+                        ...(body.title === undefined ? {} : { title: readString(body.title, "title") }),
+                        ...(body.requestId === undefined ? {} : { requestId: readString(body.requestId, "requestId") }),
+                        ...(body.metadata === undefined ? {} : { metadata: readObject(body.metadata, "metadata") }),
+                    });
+                    return json(options, thread, 201);
+                }
+                case "list": {
+                    const query = new URL(request.url).searchParams;
+                    const page = await service.list({
+                        ...input,
+                        ...(query.get("cursor") === null ? {} : { cursor: query.get("cursor") ?? undefined }),
+                        ...(query.get("limit") === null ? {} : { limit: readPositiveInt(query.get("limit"), "limit") }),
+                    });
+                    return json(options, page, 200);
+                }
+                case "get":
+                    return json(options, await service.get({ ...input, threadId: route.threadId }), 200);
+                case "continue": {
+                    const body = await readBody(request, limits.maxRequestBytes);
+                    const result = await service.continue({
+                        ...input,
+                        threadId: route.threadId,
+                        message: body.message,
+                        ...(body.requestId === undefined ? {} : { requestId: readString(body.requestId, "requestId") }),
+                        ...(body.leafId === undefined ? {} : { leafId: readString(body.leafId, "leafId") }),
+                    });
+                    return json(options, result, 200);
+                }
+                case "branch": {
+                    const body = await readBody(request, limits.maxRequestBytes);
+                    const thread = await service.branch({ ...input, threadId: route.threadId, leafId: readString(body.leafId, "leafId") });
+                    return json(options, thread, 200);
+                }
+                case "archive":
+                    return json(options, await service.archive({ ...input, threadId: route.threadId }), 200);
+                case "export": {
+                    const body = await readBody(request, limits.maxRequestBytes);
+                    const page = await service.export({
+                        ...input,
+                        threadId: route.threadId,
+                        ...(body.cursor === undefined ? {} : { cursor: readString(body.cursor, "cursor") }),
+                    });
+                    return json(options, page, 200);
+                }
+                case "delete": {
+                    const result = await service.delete({ ...input, threadId: route.threadId });
+                    return json(options, result, 200);
+                }
+                case "replay": {
+                    const query = new URL(request.url).searchParams;
+                    const page = await service.replay({
+                        ...input,
+                        threadId: route.threadId,
+                        ...(query.get("cursor") === null ? {} : { cursor: query.get("cursor") ?? undefined }),
+                        ...(query.get("limit") === null ? {} : { limit: readPositiveInt(query.get("limit"), "limit") }),
+                    });
+                    return json(options, page, 200);
+                }
+            }
+        }
+        catch (error) {
+            return conversationErrorResponse(error);
+        }
+    };
+}
+function parseConversationRoute(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");
+    }
+    if (parts.length === 0) {
+        if (request.method === "POST")
+            return { kind: "create", operation: "conversation.create" };
+        if (request.method === "GET")
+            return { kind: "list", operation: "conversation.list" };
+        return undefined;
+    }
+    const [threadId, action] = parts;
+    if (!ID_PATTERN.test(threadId) || threadId.length > 128)
+        return undefined;
+    if (parts.length === 1) {
+        if (request.method === "GET")
+            return { kind: "get", operation: "conversation.get", threadId };
+        if (request.method === "DELETE")
+            return { kind: "delete", operation: "conversation.delete", threadId };
+        return undefined;
+    }
+    if (parts.length !== 2)
+        return undefined;
+    if (action === "continue" && request.method === "POST")
+        return { kind: "continue", operation: "conversation.continue", threadId };
+    if (action === "branch" && request.method === "POST")
+        return { kind: "branch", operation: "conversation.branch", threadId };
+    if (action === "archive" && request.method === "POST")
+        return { kind: "archive", operation: "conversation.archive", threadId };
+    if (action === "export" && request.method === "POST")
+        return { kind: "export", operation: "conversation.export", threadId };
+    if (action === "events" && request.method === "GET")
+        return { kind: "replay", operation: "conversation.replay", threadId };
+    return undefined;
+}
+function json(options, value, status) {
+    const safe = options.redactor?.redact(value) ?? value;
+    return new Response(JSON.stringify(safe), { status, headers: JSON_HEADERS });
+}
+function conversationErrorResponse(error) {
+    let status = 500;
+    let code = "ERR_PRISM_SERVER_INTERNAL";
+    let message = "Internal server error";
+    if (error instanceof PrismServerError) {
+        status = error.status;
+        code = error.code;
+        message = error.message;
+    }
+    else if (error instanceof ConversationError) {
+        code = error.code;
+        message = error.message;
+        status = error.reason === "not_found" ? 404
+            : error.reason === "thread_archived" ? 409
+                : error.reason === "ownership" ? 403
+                    : error.reason === "unsupported" ? 501
+                        : error.reason === "not_redacted" || error.reason === "limit_exceeded" ? 500
+                            : 400;
+    }
+    else if (error instanceof RangeError) {
+        status = 400;
+        code = "ERR_PRISM_SERVER_INPUT";
+        message = error.message;
+    }
+    else if (error && typeof error === "object" && "code" in error && error.code === "ERR_PRISM_IDENTITY") {
+        status = 403;
+        code = "ERR_PRISM_SERVER_FORBIDDEN";
+        message = "Forbidden";
+    }
+    else if (error instanceof DOMException && error.name === "AbortError") {
+        status = 499;
+        code = "ERR_PRISM_SERVER_ABORTED";
+        message = "Request aborted";
+    }
+    return new Response(JSON.stringify({ error: { code, message } }), { status, headers: JSON_HEADERS });
+}
+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 assertOwnership(ownership) {
+    if (![ownership.tenantId, ownership.accountId, ownership.userId].some((v) => typeof v === "string" && v.length > 0)) {
+        throw new ConversationError("Ownership is required", "ownership");
+    }
+}
+function assertId(value, name) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 128 || !ID_PATTERN.test(value)) {
+        throw new ConversationError(`${name} is invalid`, "invalid_id");
+    }
+    return value;
+}
+function assertBytes(value, maxBytes, reason) {
+    if (Buffer.byteLength(value, "utf8") > maxBytes)
+        throw new ConversationError(`Value exceeds ${maxBytes} bytes`, reason);
+}
+function assertMessage(value) {
+    if (typeof value === "string" && value.length > 0)
+        return value;
+    if (isMessage(value))
+        return value;
+    if (Array.isArray(value) && value.length > 0 && value.every(isMessage))
+        return value;
+    throw new ConversationError("message must be a non-empty string, message, or message array", "invalid_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 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;
+}
+async function readBody(request, maxBytes) {
+    const text = await request.text();
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+        throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+    }
+    if (text.length === 0)
+        return {};
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("object");
+        return value;
+    }
+    catch {
+        throw new PrismServerError("Invalid JSON object body", 400, "ERR_PRISM_SERVER_BODY");
+    }
+}
+function readString(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new PrismServerError(`${name} must be a string`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+function readObject(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new PrismServerError(`${name} must be an object`, 400, "ERR_PRISM_SERVER_INPUT");
+    return value;
+}
+function readPositiveInt(value, name) {
+    const parsed = value === null ? NaN : Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1)
+        throw new PrismServerError(`${name} must be a positive safe integer`, 400, "ERR_PRISM_SERVER_INPUT");
+    return parsed;
+}
+//# sourceMappingURL=conversations.js.map

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { createPrismHandler } from "./handler.js";
+export { createConversationService, createConversationHandler, resolveConversationLimits } from "./conversations.js";
+export { DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT, HARD_CONVERSATION_THREAD_PAGE_LIMIT, DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT, HARD_CONVERSATION_REPLAY_PAGE_LIMIT, DEFAULT_CONVERSATION_CURSOR_BYTES, HARD_CONVERSATION_CURSOR_BYTES, DEFAULT_CONVERSATION_TITLE_BYTES, HARD_CONVERSATION_TITLE_BYTES, DEFAULT_CONVERSATION_REQUEST_ID_BYTES, HARD_CONVERSATION_REQUEST_ID_BYTES, DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES, HARD_CONVERSATION_MAX_ACTIVE_BRANCHES, DEFAULT_CONVERSATION_EXPORT_BYTES, HARD_CONVERSATION_EXPORT_BYTES, DEFAULT_CONVERSATION_EXPORT_PAGES, HARD_CONVERSATION_EXPORT_PAGES, DEFAULT_CONVERSATION_REQUEST_BYTES, HARD_CONVERSATION_REQUEST_BYTES, } from "./conversations.js";
+export { createArtifactService, createArtifactHandler, resolveArtifactLimits, signArtifactDeliveryLink, verifyArtifactDeliveryLink, DEFAULT_ARTIFACTS_PER_THREAD, HARD_ARTIFACTS_PER_THREAD, DEFAULT_ARTIFACT_REVISIONS, HARD_ARTIFACT_REVISIONS, DEFAULT_ARTIFACT_RECORD_BYTES, HARD_ARTIFACT_RECORD_BYTES, DEFAULT_ARTIFACT_PREVIEW_BYTES, HARD_ARTIFACT_PREVIEW_BYTES, DEFAULT_ARTIFACT_CITATIONS, HARD_ARTIFACT_CITATIONS, DEFAULT_ARTIFACT_CITATION_BYTES, HARD_ARTIFACT_CITATION_BYTES, DEFAULT_ARTIFACT_MIME_BYTES, HARD_ARTIFACT_MIME_BYTES, DEFAULT_ARTIFACT_HASH_BYTES, HARD_ARTIFACT_HASH_BYTES, DEFAULT_ARTIFACT_URI_BYTES, HARD_ARTIFACT_URI_BYTES, DEFAULT_ARTIFACT_NOTE_BYTES, HARD_ARTIFACT_NOTE_BYTES, DEFAULT_ARTIFACT_TITLE_BYTES, HARD_ARTIFACT_TITLE_BYTES, DEFAULT_ARTIFACT_LIST_PAGE_LIMIT, HARD_ARTIFACT_LIST_PAGE_LIMIT, DEFAULT_DELIVERY_LINK_TTL_SECONDS, HARD_DELIVERY_LINK_TTL_SECONDS, DEFAULT_DELIVERY_LINK_TOKEN_BYTES, HARD_DELIVERY_LINK_TOKEN_BYTES, DEFAULT_ARTIFACT_REQUEST_BYTES, HARD_ARTIFACT_REQUEST_BYTES, } from "./artifacts.js";
 export { createPrismDrainController, isAdmitOperation } from "./drain.js";
 export { createPrismHealthHandler } from "./health.js";
 export { createMemoryRateLimiter } from "./rate-limit.js";
@@ -12,5 +15,7 @@ export type { CreatePrismHealthHandlerOptions } from "./health.js";
 export type { PrismServerRateLimiter, PrismServerRateLimitDenial, PrismServerRateLimitInput, MemoryRateLimiterOptions, } from "./rate-limit.js";
 export type { PrismEventReplay, PrismEventReplayRequest, CreatePrismEventReplayOptions, CreatePrismReplayHandlerOptions, } from "./replay.js";
 export type { PrismDeploymentLease, PrismDeploymentLeaseOptions } from "./deployment.js";
+export type { ConversationLimits, ResolvedConversationLimits, ConversationServiceStore, ConversationSessionFactoryInput, CreateConversationServiceOptions, ConversationServiceInput, ConversationCreateInput, ConversationListInput, ConversationRefInput, ConversationContinueInput, ConversationBranchInput, ConversationExportInput, ConversationReplayInput, ConversationReplayPage, ConversationExportPage, ConversationService, ConversationOperation, ConversationAuthorizationInput, ConversationAuthorizer, CreateConversationHandlerOptions, } from "./conversations.js";
+export type { ArtifactLimits, ResolvedArtifactLimits, ArtifactServiceInput, ArtifactAttachInput, ArtifactListInput, ArtifactRefInput, ArtifactReviseInput, ArtifactCompareInput, ArtifactCompareResult, ArtifactDecisionInput, ArtifactDeliveryInput, ArtifactDeliveryResult, ArtifactDecisionEvent, CreateArtifactServiceOptions, ArtifactService, ArtifactOperation, ArtifactAuthorizationInput, ArtifactAuthorizer, CreateArtifactHandlerOptions, } from "./artifacts.js";
 export { PrismServerError } from "./types.js";
 export declare const packageName = "@arnilo/prism-server";

package/dist/index.js

@@ -1,4 +1,7 @@
 export { createPrismHandler } from "./handler.js";
+export { createConversationService, createConversationHandler, resolveConversationLimits } from "./conversations.js";
+export { DEFAULT_CONVERSATION_THREAD_PAGE_LIMIT, HARD_CONVERSATION_THREAD_PAGE_LIMIT, DEFAULT_CONVERSATION_REPLAY_PAGE_LIMIT, HARD_CONVERSATION_REPLAY_PAGE_LIMIT, DEFAULT_CONVERSATION_CURSOR_BYTES, HARD_CONVERSATION_CURSOR_BYTES, DEFAULT_CONVERSATION_TITLE_BYTES, HARD_CONVERSATION_TITLE_BYTES, DEFAULT_CONVERSATION_REQUEST_ID_BYTES, HARD_CONVERSATION_REQUEST_ID_BYTES, DEFAULT_CONVERSATION_MAX_ACTIVE_BRANCHES, HARD_CONVERSATION_MAX_ACTIVE_BRANCHES, DEFAULT_CONVERSATION_EXPORT_BYTES, HARD_CONVERSATION_EXPORT_BYTES, DEFAULT_CONVERSATION_EXPORT_PAGES, HARD_CONVERSATION_EXPORT_PAGES, DEFAULT_CONVERSATION_REQUEST_BYTES, HARD_CONVERSATION_REQUEST_BYTES, } from "./conversations.js";
+export { createArtifactService, createArtifactHandler, resolveArtifactLimits, signArtifactDeliveryLink, verifyArtifactDeliveryLink, DEFAULT_ARTIFACTS_PER_THREAD, HARD_ARTIFACTS_PER_THREAD, DEFAULT_ARTIFACT_REVISIONS, HARD_ARTIFACT_REVISIONS, DEFAULT_ARTIFACT_RECORD_BYTES, HARD_ARTIFACT_RECORD_BYTES, DEFAULT_ARTIFACT_PREVIEW_BYTES, HARD_ARTIFACT_PREVIEW_BYTES, DEFAULT_ARTIFACT_CITATIONS, HARD_ARTIFACT_CITATIONS, DEFAULT_ARTIFACT_CITATION_BYTES, HARD_ARTIFACT_CITATION_BYTES, DEFAULT_ARTIFACT_MIME_BYTES, HARD_ARTIFACT_MIME_BYTES, DEFAULT_ARTIFACT_HASH_BYTES, HARD_ARTIFACT_HASH_BYTES, DEFAULT_ARTIFACT_URI_BYTES, HARD_ARTIFACT_URI_BYTES, DEFAULT_ARTIFACT_NOTE_BYTES, HARD_ARTIFACT_NOTE_BYTES, DEFAULT_ARTIFACT_TITLE_BYTES, HARD_ARTIFACT_TITLE_BYTES, DEFAULT_ARTIFACT_LIST_PAGE_LIMIT, HARD_ARTIFACT_LIST_PAGE_LIMIT, DEFAULT_DELIVERY_LINK_TTL_SECONDS, HARD_DELIVERY_LINK_TTL_SECONDS, DEFAULT_DELIVERY_LINK_TOKEN_BYTES, HARD_DELIVERY_LINK_TOKEN_BYTES, DEFAULT_ARTIFACT_REQUEST_BYTES, HARD_ARTIFACT_REQUEST_BYTES, } from "./artifacts.js";
 export { createPrismDrainController, isAdmitOperation } from "./drain.js";
 export { createPrismHealthHandler } from "./health.js";
 export { createMemoryRateLimiter } from "./rate-limit.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-server",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Optional framework-free Web Request-to-Response handler for explicitly selected Prism agents and workflows.",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,11 +25,12 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.13",
-    "@arnilo/prism-workflows": "0.0.13"
+    "@arnilo/prism": "0.0.15",
+    "@arnilo/prism-workflows": "0.0.15"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",
+    "@arnilo/prism-session-store-sqlite": "file:../session-store-sqlite",
     "@arnilo/prism-workflows": "file:../workflows"
   },
   "engines": {