@arnilo/prism 0.0.4 → 0.0.6

package/dist/feedback.js

@@ -0,0 +1,230 @@
+export const DEFAULT_MAX_FEEDBACK_COMMENT_BYTES = 4096;
+export const HARD_MAX_FEEDBACK_COMMENT_BYTES = 16384;
+export const DEFAULT_MAX_FEEDBACK_TAGS = 16;
+export const HARD_MAX_FEEDBACK_TAGS = 64;
+export const DEFAULT_MAX_FEEDBACK_LINKS = 16;
+export const HARD_MAX_FEEDBACK_LINKS = 64;
+export const DEFAULT_MAX_FEEDBACK_METADATA_BYTES = 16384;
+export const HARD_MAX_FEEDBACK_METADATA_BYTES = 65536;
+export const DEFAULT_FEEDBACK_PAGE_SIZE = 100;
+export const HARD_FEEDBACK_PAGE_SIZE = 500;
+export const MAX_FEEDBACK_TAG_LENGTH = 64;
+export const MAX_FEEDBACK_ID_LENGTH = 128;
+export class RunFeedbackError extends Error {
+    code;
+    constructor(message, code = "ERR_PRISM_RUN_FEEDBACK") {
+        super(message);
+        this.name = "RunFeedbackError";
+        this.code = code;
+    }
+}
+/** Validate, ownership-check, redact, bound, and freeze one feedback record. */
+export async function prepareRunFeedback(input, options) {
+    input.signal?.throwIfAborted();
+    const ownership = requireOwnership(input);
+    const id = requireId(input.id, "feedback id");
+    const runId = requireId(input.runId, "runId");
+    const run = await options.resolveRun({ runId, ownership, signal: input.signal });
+    input.signal?.throwIfAborted();
+    if (!run || run.runId !== runId || !sameOwnership(ownership, run)) {
+        throw new RunFeedbackError("Run not found", "ERR_PRISM_RUN_FEEDBACK_RUN_NOT_FOUND");
+    }
+    if (input.sessionId !== undefined && input.sessionId !== run.sessionId) {
+        throw new RunFeedbackError("Run not found", "ERR_PRISM_RUN_FEEDBACK_RUN_NOT_FOUND");
+    }
+    if (input.traceId !== undefined && run.traceId !== undefined && input.traceId !== run.traceId) {
+        throw new RunFeedbackError("Run not found", "ERR_PRISM_RUN_FEEDBACK_RUN_NOT_FOUND");
+    }
+    if (input.comment !== undefined && !input.comment.trim()) {
+        throw new RunFeedbackError("comment must not be empty", "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+    }
+    if (input.rating !== undefined && (!Number.isFinite(input.rating) || input.rating < -1 || input.rating > 1)) {
+        throw new RunFeedbackError("rating must be a finite number in [-1, 1]", "ERR_PRISM_RUN_FEEDBACK_BOUNDS");
+    }
+    const maxCommentBytes = boundedLimit(options.maxCommentBytes, DEFAULT_MAX_FEEDBACK_COMMENT_BYTES, HARD_MAX_FEEDBACK_COMMENT_BYTES, "maxCommentBytes");
+    const maxTags = boundedLimit(options.maxTags, DEFAULT_MAX_FEEDBACK_TAGS, HARD_MAX_FEEDBACK_TAGS, "maxTags");
+    const maxLinks = boundedLimit(options.maxLinks, DEFAULT_MAX_FEEDBACK_LINKS, HARD_MAX_FEEDBACK_LINKS, "maxLinks");
+    const maxMetadataBytes = boundedLimit(options.maxMetadataBytes, DEFAULT_MAX_FEEDBACK_METADATA_BYTES, HARD_MAX_FEEDBACK_METADATA_BYTES, "maxMetadataBytes");
+    const tags = normalizeList(input.tags, maxTags, MAX_FEEDBACK_TAG_LENGTH, "tag");
+    const scorerIds = normalizeList(input.scorerIds, maxLinks, MAX_FEEDBACK_ID_LENGTH, "scorer id", true);
+    const evaluationIds = normalizeList(input.evaluationIds, maxLinks, MAX_FEEDBACK_ID_LENGTH, "evaluation id", true);
+    if (input.rating === undefined && input.comment === undefined && tags.length === 0 && scorerIds.length === 0 && evaluationIds.length === 0) {
+        throw new RunFeedbackError("feedback requires rating, comment, tag, scorer, or evaluation", "ERR_PRISM_RUN_FEEDBACK_EMPTY");
+    }
+    const redact = (value) => options.redactor ? options.redactor.redact(value) : value;
+    const comment = input.comment === undefined ? undefined : redact(input.comment);
+    const safeTags = Object.freeze(normalizeList(redact(tags), maxTags, MAX_FEEDBACK_TAG_LENGTH, "tag"));
+    const metadata = input.metadata === undefined ? undefined : redact(input.metadata);
+    assertBytes(comment, maxCommentBytes, "comment");
+    assertBytes(metadata, maxMetadataBytes, "metadata");
+    const createdAt = input.createdAt ?? new Date().toISOString();
+    if (!Number.isFinite(Date.parse(createdAt)))
+        throw new RunFeedbackError("createdAt must be an ISO timestamp", "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+    return Object.freeze({
+        id,
+        runId,
+        sessionId: run.sessionId,
+        traceId: input.traceId ?? run.traceId,
+        rating: input.rating,
+        comment,
+        tags: safeTags,
+        scorerIds: Object.freeze(scorerIds),
+        evaluationIds: Object.freeze(evaluationIds),
+        createdAt,
+        createdBy: input.createdBy === undefined ? undefined : requireId(input.createdBy, "createdBy"),
+        metadata: metadata === undefined ? undefined : cloneFrozenJsonObject(metadata),
+        ...ownership,
+    });
+}
+/** In-memory implementation with the same validation/ownership semantics as durable adapters. */
+export function createMemoryRunFeedbackStore(options) {
+    const records = new Map();
+    for (const record of options.initial ?? [])
+        records.set(record.id, freezeRecord(record));
+    const maxPageSize = boundedLimit(options.maxPageSize, DEFAULT_FEEDBACK_PAGE_SIZE, HARD_FEEDBACK_PAGE_SIZE, "maxPageSize");
+    return {
+        async append(input) {
+            if (records.has(input.id))
+                throw new RunFeedbackError("Duplicate feedback id", "ERR_PRISM_RUN_FEEDBACK_DUPLICATE");
+            const record = await prepareRunFeedback(input, options);
+            records.set(record.id, record);
+            return record;
+        },
+        async query(query) {
+            query.signal?.throwIfAborted();
+            const ownership = requireOwnership(query);
+            const limit = pageLimit(query.limit, maxPageSize);
+            const order = query.order === "desc" ? -1 : 1;
+            const sorted = [...records.values()]
+                .filter((record) => sameOwnership(ownership, record) && matchesQuery(record, query))
+                .sort((a, b) => order * (a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)));
+            const start = query.cursor ? sorted.findIndex((record) => record.id === query.cursor) + 1 : 0;
+            if (query.cursor && start === 0)
+                throw new RunFeedbackError("Unknown feedback cursor", "ERR_PRISM_RUN_FEEDBACK_CURSOR");
+            const items = sorted.slice(start, start + limit);
+            return { items, nextCursor: start + items.length < sorted.length ? items.at(-1)?.id : undefined, total: sorted.length };
+        },
+        async delete(input) {
+            input.signal?.throwIfAborted();
+            const ownership = requireOwnership(input);
+            const current = records.get(input.id);
+            if (!current || !sameOwnership(ownership, current))
+                return false;
+            return records.delete(input.id);
+        },
+    };
+}
+export function requireRunFeedbackOwnership(input) {
+    return requireOwnership(input);
+}
+export function runFeedbackPageLimit(limit, maximum = HARD_FEEDBACK_PAGE_SIZE) {
+    return pageLimit(limit, maximum);
+}
+function requireOwnership(input) {
+    if (!input.tenantId?.trim()
+        || (input.accountId !== undefined && !input.accountId.trim())
+        || (input.userId !== undefined && !input.userId.trim())
+        || (!input.accountId && !input.userId)) {
+        throw new RunFeedbackError("tenantId and non-empty accountId or userId are required", "ERR_PRISM_RUN_FEEDBACK_OWNERSHIP");
+    }
+    return { tenantId: input.tenantId, accountId: input.accountId, userId: input.userId };
+}
+function sameOwnership(expected, actual) {
+    return expected.tenantId === actual.tenantId
+        && expected.accountId === actual.accountId
+        && expected.userId === actual.userId;
+}
+function requireId(value, label) {
+    if (!value || value.length > MAX_FEEDBACK_ID_LENGTH || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value)) {
+        throw new RunFeedbackError(`${label} is invalid`, "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+    }
+    return value;
+}
+function normalizeList(values, maximum, maxLength, label, ids = false) {
+    if (!values)
+        return [];
+    if (values.length > maximum)
+        throw new RunFeedbackError(`Too many ${label}s`, "ERR_PRISM_RUN_FEEDBACK_BOUNDS");
+    const result = values.map((value) => {
+        if (typeof value !== "string" || !value.trim() || value.length > maxLength || /[\r\n]/.test(value)) {
+            throw new RunFeedbackError(`${label} is invalid`, "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+        }
+        return ids ? requireId(value, label) : value;
+    });
+    if (new Set(result).size !== result.length)
+        throw new RunFeedbackError(`Duplicate ${label}`, "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+    return result;
+}
+function boundedLimit(value, fallback, hard, label) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > hard) {
+        throw new RunFeedbackError(`${label} must be an integer in [1, ${hard}]`, "ERR_PRISM_RUN_FEEDBACK_BOUNDS");
+    }
+    return resolved;
+}
+function pageLimit(value, maximum) {
+    if (value === undefined)
+        return Math.min(DEFAULT_FEEDBACK_PAGE_SIZE, maximum);
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new RunFeedbackError("limit must be a positive integer", "ERR_PRISM_RUN_FEEDBACK_BOUNDS");
+    return Math.min(value, maximum);
+}
+function assertBytes(value, maximum, label) {
+    if (value === undefined)
+        return;
+    let encoded;
+    try {
+        encoded = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    catch {
+        throw new RunFeedbackError(`${label} must be JSON serializable`, "ERR_PRISM_RUN_FEEDBACK_VALIDATION");
+    }
+    if (new TextEncoder().encode(encoded).byteLength > maximum) {
+        throw new RunFeedbackError(`${label} exceeds ${maximum} bytes`, "ERR_PRISM_RUN_FEEDBACK_BOUNDS");
+    }
+}
+function matchesQuery(record, query) {
+    if (query.runId !== undefined && record.runId !== query.runId)
+        return false;
+    if (query.sessionId !== undefined && record.sessionId !== query.sessionId)
+        return false;
+    if (query.traceId !== undefined && record.traceId !== query.traceId)
+        return false;
+    if (query.rating !== undefined && record.rating !== query.rating)
+        return false;
+    if (query.scorerId !== undefined && !record.scorerIds.includes(query.scorerId))
+        return false;
+    if (query.evaluationId !== undefined && !record.evaluationIds.includes(query.evaluationId))
+        return false;
+    if (query.tag !== undefined && !record.tags.includes(query.tag))
+        return false;
+    if (query.fromCreatedAt !== undefined && record.createdAt < query.fromCreatedAt)
+        return false;
+    if (query.toCreatedAt !== undefined && record.createdAt > query.toCreatedAt)
+        return false;
+    return true;
+}
+function freezeRecord(record) {
+    return Object.freeze({
+        ...record,
+        tags: Object.freeze([...record.tags]),
+        scorerIds: Object.freeze([...record.scorerIds]),
+        evaluationIds: Object.freeze([...record.evaluationIds]),
+        metadata: record.metadata ? cloneFrozenJsonObject(record.metadata) : undefined,
+    });
+}
+function cloneFrozenJsonObject(value) {
+    const cloned = JSON.parse(JSON.stringify(value));
+    if (!cloned || typeof cloned !== "object" || Array.isArray(cloned))
+        throw new RunFeedbackError("metadata must be a JSON object");
+    return deepFreeze(cloned);
+}
+function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+//# sourceMappingURL=feedback.js.map

package/dist/ids.d.ts

@@ -0,0 +1,2 @@
+/** Cryptographically unpredictable identifier for internal Prism records. */
+export declare function createId(prefix: string): string;

package/dist/ids.js

@@ -0,0 +1,6 @@
+import { randomUUID } from "node:crypto";
+/** Cryptographically unpredictable identifier for internal Prism records. */
+export function createId(prefix) {
+    return `${prefix}_${randomUUID()}`;
+}
+//# sourceMappingURL=ids.js.map

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export type * from "./contracts.js";
-export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
+export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict, AgentRunError } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.js";
+export { createMemoryRunFeedbackStore, prepareRunFeedback, requireRunFeedbackOwnership, runFeedbackPageLimit, RunFeedbackError, } from "./feedback.js";
+export type { MemoryRunFeedbackStoreOptions, PrepareRunFeedbackOptions, RunFeedbackLimits, RunFeedbackRun, RunFeedbackRunResolver, } from "./feedback.js";
 export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpointStore } from "./checkpoints.js";
 export type { MemoryCheckpointStoreOptions } from "./checkpoints.js";
 export { LEASE_CONFLICT_CODE, LeaseConflictError, createMemoryLeaseStore } from "./leases.js";
@@ -28,13 +30,17 @@ export { assertStructuredOutputRequestSupported, DEFAULT_MAX_STRUCTURED_OUTPUT_N
 export { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
 export { createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions } from "./provider-request-policy.js";
 export type { SessionCachePolicyOptions } from "./provider-request-policy.js";
+export { THINKING_LEVELS, applyThinkingLevel, isThinkingLevel, normalizeThinkingLevel, thinkingCompatFor, thinkingFamilyForModel, } from "./thinking.js";
+export type { ThinkingCompatFamily, ThinkingLevel } from "./thinking.js";
+export { resolveUseCaseModel, resolveUseCaseModelBinding, useCaseCredentialProviderId, } from "./use-case-model.js";
+export type { ResolveUseCaseModelInput, ResolvedUseCaseModel, UseCaseModelBinding, } from "./use-case-model.js";
 export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
 export type { ComposeSystemPromptOptions } from "./system-prompts.js";
 export type { ModelRegistry, ModelRegistryOptions } from "./models.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
 export type { ManifestContributionDeclaration, ManifestContributionKind, ManifestResourceDeclaration, PrismManifest } from "./manifests.js";
-export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMessagesSupportModelCapabilities, assertModelSupportsContentBlocks, assertSsrfAllowedUrl, collectMessageContentBlocks, contentBlockInputModality, DEFAULT_MAX_AUDIO_DURATION_MS, DEFAULT_MAX_MEDIA_ITEM_BYTES, DEFAULT_MAX_MEDIA_ITEMS_PER_REQUEST, DEFAULT_MAX_MEDIA_REQUEST_BYTES, DEFAULT_MEDIA_FETCH_TIMEOUT_MS, loadBoundedBinaryResource, MediaContentError, MODEL_INPUT_CAPABILITIES, resolveMediaContentBlock, sniffMediaMimeType, UnsupportedModalityError, } from "./content.js";
-export type { AudioContent, DocumentContent, FileContent, MediaContentBlock, MediaContentBounds, MediaMimePolicy, ModelInputCapability, ResolvedMediaContent, ResolveMediaContentOptions, SsrfPolicy, } from "./content.js";
+export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMessagesSupportModelCapabilities, assertModelSupportsContentBlocks, assertSsrfAllowedUrl, collectMessageContentBlocks, contentBlockInputModality, DEFAULT_MAX_AUDIO_DURATION_MS, DEFAULT_MAX_MEDIA_ITEM_BYTES, DEFAULT_MAX_MEDIA_ITEMS_PER_REQUEST, DEFAULT_MAX_MEDIA_REQUEST_BYTES, DEFAULT_MEDIA_FETCH_TIMEOUT_MS, loadBoundedBinaryResource, MediaContentError, MODEL_INPUT_CAPABILITIES, resolveMediaContentBlock, resolveMediaContentBlocks, sniffMediaMimeType, UnsupportedModalityError, } from "./content.js";
+export type { AudioContent, DocumentContent, FileContent, MediaContentBlock, MediaContentBounds, MediaHostAddress, MediaHostnameResolver, MediaMimePolicy, MediaUrlRequest, MediaUrlRequester, ModelInputCapability, ResolvedMediaContent, ResolveMediaContentOptions, SsrfPolicy, } from "./content.js";
 export { loadBinaryResource, loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
 export type { LoadBinaryResourceOptions } from "./resources.js";
 export { createChainedSettingsProvider, createStaticSettingsProvider } from "./settings.js";
@@ -65,5 +71,5 @@ export type { DispatchToolCallOptions, ToolArgumentValidationError, ToolArgument
 export type { DuplicateRegistrationOptions, DuplicateRegistrationPolicy } from "./registry-options.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop } from "./agent-loops.js";
 export declare const name = "prism";
-export declare const version = "0.0.4";
+export declare const version = "0.0.6";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,5 +1,6 @@
-export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
+export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict, AgentRunError } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.js";
+export { createMemoryRunFeedbackStore, prepareRunFeedback, requireRunFeedbackOwnership, runFeedbackPageLimit, RunFeedbackError, } from "./feedback.js";
 export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpointStore } from "./checkpoints.js";
 export { LEASE_CONFLICT_CODE, LeaseConflictError, createMemoryLeaseStore } from "./leases.js";
 export { createEventMultiplexer } from "./event-multiplexer.js";
@@ -17,9 +18,11 @@ export { authMethodKey, defineProviderPackage, systemPromptContributionKey } fro
 export { assertStructuredOutputRequestSupported, DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH, DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES, modelSupportsStructuredOutput, resolveRunProviderOptions, StructuredOutputError, validateStructuredOutputOptions, } from "./structured-output.js";
 export { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
 export { createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions } from "./provider-request-policy.js";
+export { THINKING_LEVELS, applyThinkingLevel, isThinkingLevel, normalizeThinkingLevel, thinkingCompatFor, thinkingFamilyForModel, } from "./thinking.js";
+export { resolveUseCaseModel, resolveUseCaseModelBinding, useCaseCredentialProviderId, } from "./use-case-model.js";
 export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
-export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMessagesSupportModelCapabilities, assertModelSupportsContentBlocks, assertSsrfAllowedUrl, collectMessageContentBlocks, contentBlockInputModality, DEFAULT_MAX_AUDIO_DURATION_MS, DEFAULT_MAX_MEDIA_ITEM_BYTES, DEFAULT_MAX_MEDIA_ITEMS_PER_REQUEST, DEFAULT_MAX_MEDIA_REQUEST_BYTES, DEFAULT_MEDIA_FETCH_TIMEOUT_MS, loadBoundedBinaryResource, MediaContentError, MODEL_INPUT_CAPABILITIES, resolveMediaContentBlock, sniffMediaMimeType, UnsupportedModalityError, } from "./content.js";
+export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMessagesSupportModelCapabilities, assertModelSupportsContentBlocks, assertSsrfAllowedUrl, collectMessageContentBlocks, contentBlockInputModality, DEFAULT_MAX_AUDIO_DURATION_MS, DEFAULT_MAX_MEDIA_ITEM_BYTES, DEFAULT_MAX_MEDIA_ITEMS_PER_REQUEST, DEFAULT_MAX_MEDIA_REQUEST_BYTES, DEFAULT_MEDIA_FETCH_TIMEOUT_MS, loadBoundedBinaryResource, MediaContentError, MODEL_INPUT_CAPABILITIES, resolveMediaContentBlock, resolveMediaContentBlocks, sniffMediaMimeType, UnsupportedModalityError, } from "./content.js";
 export { loadBinaryResource, loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
 export { createChainedSettingsProvider, createStaticSettingsProvider } from "./settings.js";
 export { createMiddlewareRegistry } from "./middleware.js";
@@ -36,6 +39,6 @@ export { resolveInstructionInjectors, runInstructionInjectors } from "./instruct
 export { createToolRegistry, dispatchToolCall, filterTools, createToolParameterValidator } from "./tools.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop } from "./agent-loops.js";
 export const name = "prism";
-export const version = "0.0.4";
+export const version = "0.0.6";
 export const description = "Agent harness for AI providers, agents, sessions, and tools.";
 //# sourceMappingURL=index.js.map

package/dist/providers/media.d.ts

@@ -1,4 +1,4 @@
-import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, ModelCapabilities, ModelConfig } from "../contracts.js";
+import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
 import { type MediaContentBlock, type ModelInputCapability, type ResolveMediaContentOptions, type ResolvedMediaContent } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export declare const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
@@ -38,5 +38,7 @@ export declare function serializePdfDocumentWireBlock(options: {
     readonly title?: string;
 }): JsonObject;
 export declare function resolveProviderMediaBlock(block: AudioContent | FileContent | DocumentContent, options?: ResolveMediaContentOptions): Promise<ResolvedMediaContent>;
+/** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
+export declare function resolveProviderMediaMessages(messages: readonly Message[], model: ModelConfig, options?: ResolveMediaContentOptions): Promise<ReadonlyMap<MediaContentBlock, ResolvedMediaContent>>;
 export declare function defaultProviderFilename(block: MediaContentBlock, fallback: string): string;
 export declare const DEFAULT_PROVIDER_MEDIA_ITEM_BYTES = 10000000;

package/dist/providers/media.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlock, UnsupportedModalityError, } from "../content.js";
+import { assertMessagesSupportModelCapabilities, contentBlockInputModality, DEFAULT_MAX_MEDIA_ITEM_BYTES, resolveMediaContentBlock, resolveMediaContentBlocks, UnsupportedModalityError, } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */
@@ -96,6 +96,16 @@ export function serializePdfDocumentWireBlock(options) {
 export async function resolveProviderMediaBlock(block, options = {}) {
     return resolveMediaContentBlock(block, options);
 }
+/** Resolve every media block once and enforce aggregate request bounds before provider I/O. */
+export async function resolveProviderMediaMessages(messages, model, options = {}) {
+    assertMessagesSupportModelCapabilities(model, messages);
+    const blocks = messages.flatMap((message) => message.content.filter(isMediaContentBlock));
+    const resolved = await resolveMediaContentBlocks(blocks, options);
+    return new Map(blocks.map((block, index) => [block, resolved[index]]));
+}
+function isMediaContentBlock(block) {
+    return contentBlockInputModality(block) !== undefined;
+}
 export function defaultProviderFilename(block, fallback) {
     if ("name" in block && block.name)
         return block.name;

package/dist/session-stores.js

@@ -1,4 +1,5 @@
 import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError } from "./contracts.js";
+import { createId } from "./ids.js";
 export function createSessionEntry(options) {
     const { createId, now, ...entry } = options;
     return {
@@ -171,7 +172,5 @@ function indexEntries(entries) {
     }
     return { byId, parentIds };
 }
-function randomId(prefix) {
-    return `${prefix}_${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
-}
+const randomId = createId;
 //# sourceMappingURL=session-stores.js.map

package/dist/testing/feedback.d.ts

@@ -0,0 +1,6 @@
+import type { RunFeedbackStore } from "../contracts.js";
+export interface RunFeedbackConformanceFactory {
+    (): RunFeedbackStore | Promise<RunFeedbackStore>;
+}
+/** Shared minimum behavior for memory and production feedback stores. */
+export declare function runFeedbackConformance(factory: RunFeedbackConformanceFactory): Promise<void>;

package/dist/testing/feedback.js

@@ -0,0 +1,37 @@
+/** Shared minimum behavior for memory and production feedback stores. */
+export async function runFeedbackConformance(factory) {
+    const store = await factory();
+    const owner = { tenantId: "feedback-tenant", userId: "feedback-user" };
+    await store.append({
+        id: "feedback-1",
+        runId: "feedback-run-a",
+        rating: 1,
+        comment: "useful",
+        tags: ["reviewed"],
+        evaluationIds: ["eval-1"],
+        createdAt: "2026-01-01T00:00:00.000Z",
+        ...owner,
+    });
+    await store.append({
+        id: "feedback-2",
+        runId: "feedback-run-a",
+        rating: 0,
+        createdAt: "2026-01-01T00:00:01.000Z",
+        ...owner,
+    });
+    const first = await store.query({ ...owner, runId: "feedback-run-a", limit: 1 });
+    if (first.items.length !== 1 || !first.nextCursor)
+        throw new Error("feedback first page is invalid");
+    const second = await store.query({ ...owner, runId: "feedback-run-a", cursor: first.nextCursor, limit: 1 });
+    if (second.items.length !== 1 || second.items[0]?.id === first.items[0]?.id)
+        throw new Error("feedback cursor did not advance");
+    const linked = await store.query({ ...owner, evaluationId: "eval-1" });
+    if (linked.items.length !== 1 || linked.items[0]?.id !== "feedback-1")
+        throw new Error("feedback evaluation filter failed");
+    if (await store.delete({ id: "feedback-1", tenantId: "feedback-tenant", userId: "other" })) {
+        throw new Error("cross-owner feedback deletion succeeded");
+    }
+    if (!await store.delete({ id: "feedback-1", ...owner }))
+        throw new Error("owned feedback deletion failed");
+}
+//# sourceMappingURL=feedback.js.map

package/dist/testing/persistence-schema.d.ts

@@ -1,12 +1,14 @@
 import type { PersistencePage, SessionEntry, SessionEntryQuery } from "../contracts.js";
 /** Current shared persistence schema version for production database adapters. */
-export declare const PERSISTENCE_SCHEMA_VERSION = 1;
-export type PersistenceTableName = "prism_tenants" | "prism_accounts" | "prism_users" | "prism_agent_definitions" | "prism_sessions" | "prism_branches" | "prism_session_entries" | "prism_session_append_idempotency" | "prism_runs" | "prism_agent_events" | "prism_tool_calls" | "prism_usage" | "prism_retention_policies" | "prism_migrations";
-export type PersistenceColumnType = "text" | "integer" | "boolean" | "json" | "timestamp";
+export declare const PERSISTENCE_SCHEMA_VERSION = 3;
+export type PersistenceTableName = "prism_tenants" | "prism_accounts" | "prism_users" | "prism_agent_definitions" | "prism_sessions" | "prism_branches" | "prism_session_entries" | "prism_session_append_idempotency" | "prism_runs" | "prism_agent_events" | "prism_tool_calls" | "prism_usage" | "prism_run_feedback" | "prism_retention_policies" | "prism_migrations";
+export type PersistenceColumnType = "text" | "integer" | "number" | "boolean" | "json" | "timestamp";
 export interface PersistenceColumnDefinition {
     readonly name: string;
     readonly type: PersistenceColumnType;
     readonly nullable?: boolean;
+    /** Portable SQL default literal, if the schema requires one. */
+    readonly defaultValue?: string;
     /** Column participates in tenant isolation boundaries when true. */
     readonly tenantScoped?: boolean;
 }
@@ -42,6 +44,8 @@ export interface PersistenceMigrationStep {
     readonly version: number;
     readonly name: string;
     readonly description?: string;
+    /** SHA-256 of the canonical checked-in migration schema content. */
+    readonly checksum: string;
 }
 /** Versioned migration expectations shared by production database adapters. */
 export interface PersistenceMigrationContract {
@@ -74,6 +78,46 @@ export declare function tenantScopedUniqueKey(baseColumns: readonly string[], te
 export declare function assertPersistenceSchemaModel(model: PersistenceSchemaModel): void;
 /** Assert migration steps are strictly increasing and end at the target schema version. */
 export declare function assertPersistenceMigrationContract(contract: PersistenceMigrationContract): void;
+export type PersistenceSchemaDialect = "sqlite" | "postgres";
+export interface PersistenceSchemaShapeColumn {
+    readonly name: string;
+    readonly type: string;
+    readonly nullable: boolean;
+    readonly defaultValue?: string;
+}
+export interface PersistenceSchemaShapeForeignKey {
+    readonly columns: readonly string[];
+    readonly referencesTable: string;
+    readonly referencesColumns: readonly string[];
+}
+export interface PersistenceSchemaShapeTable {
+    readonly name: string;
+    readonly columns: readonly PersistenceSchemaShapeColumn[];
+    readonly primaryKey: readonly string[];
+    readonly uniqueKeys: readonly (readonly string[])[];
+    readonly foreignKeys: readonly PersistenceSchemaShapeForeignKey[];
+}
+export interface PersistenceSchemaShapeIndex {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly unique: boolean;
+}
+export interface PersistenceSchemaShape {
+    readonly tables: readonly PersistenceSchemaShapeTable[];
+    readonly indexes: readonly PersistenceSchemaShapeIndex[];
+}
+/** Compare bounded dialect catalog output against every required schema-v3 detail. */
+export declare function assertPersistenceSchemaShape(shape: PersistenceSchemaShape, dialect: PersistenceSchemaDialect, model?: PersistenceSchemaModel): void;
+export interface AppliedPersistenceMigration {
+    readonly name: string;
+    readonly version: string;
+    readonly checksum: string | null;
+}
+/** Reject altered migration history before any new DDL or runtime write. */
+export declare function assertAppliedPersistenceMigrations(contract: PersistenceMigrationContract, applied: readonly AppliedPersistenceMigration[]): {
+    readonly legacyChecksums: boolean;
+};
 /**
  * Assert a dialect-local adapter exposes the canonical table and index names.
  * Adapters pass the table/index names their migration runner created.
@@ -82,13 +126,7 @@ export declare function assertAdapterSchemaMatchesModel(adapterTables: readonly
 /** Guard adapter SQL tests: reject obvious value interpolation into statement text. */
 export declare function assertParameterizedQuery(sql: string, boundValues: readonly unknown[]): void;
 /** Simulate migration up + reopen: applied steps must match the contract in order. */
-export declare function assertMigrationUpAndReopen(contract: PersistenceMigrationContract, appliedAfterUp: readonly {
-    readonly name: string;
-    readonly version: string;
-}[], appliedAfterReopen: readonly {
-    readonly name: string;
-    readonly version: string;
-}[]): void;
+export declare function assertMigrationUpAndReopen(contract: PersistenceMigrationContract, appliedAfterUp: readonly AppliedPersistenceMigration[], appliedAfterReopen: readonly AppliedPersistenceMigration[]): void;
 export interface PersistenceQueryConformanceFixture {
     readonly seedEntries: (entries: readonly SessionEntry[]) => Promise<void> | void;
     readonly queryEntries: (query: SessionEntryQuery) => Promise<PersistencePage<SessionEntry>>;