@arnilo/prism 0.0.4 → 0.0.5

package/dist/content.js

@@ -1,3 +1,7 @@
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
 import { assertPermission } from "./security.js";
 /** Known model input capability tags for `ModelCapabilities.input`. */
 export const MODEL_INPUT_CAPABILITIES = ["text", "image", "audio", "file", "document"];
@@ -99,9 +103,9 @@ export function assertSsrfAllowedUrl(url, policy = {}) {
     if (parsed.username || parsed.password) {
         throw new MediaContentError("ssrf_denied", "Media URL must not embed credentials");
     }
-    const hostname = parsed.hostname.toLowerCase();
+    const hostname = normalizeHostname(parsed.hostname);
     if (policy.allowedHostnames?.length) {
-        if (!policy.allowedHostnames.some((allowed) => hostname === allowed.toLowerCase())) {
+        if (!policy.allowedHostnames.some((allowed) => hostname === normalizeHostname(allowed))) {
             throw new MediaContentError("ssrf_denied", `Media URL host ${hostname} is not allow-listed`);
         }
         return;
@@ -158,10 +162,28 @@ export function assertDeclaredMediaTypeMatches(declaredMediaType, bytes, policy
     }
 }
 export async function resolveMediaContentBlock(block, options = {}) {
+    return (await resolveMediaContentBlocks([block], options))[0];
+}
+/** Resolve and validate one complete media request before provider serialization/upload. */
+export async function resolveMediaContentBlocks(blocks, options = {}) {
+    const bounds = options.bounds ?? {};
+    const maxRequestBytes = bounds.maxRequestBytes ?? DEFAULT_MAX_MEDIA_REQUEST_BYTES;
+    assertMediaBlocksWithinBounds(blocks, bounds);
+    const resolved = [];
+    let requestBytes = 0;
+    for (const block of blocks) {
+        const item = await resolveMediaBlock(block, options);
+        requestBytes += item.bytes.byteLength;
+        if (requestBytes > maxRequestBytes) {
+            throw new MediaContentError("request_too_large", `Media request budget exceeded ${maxRequestBytes} bytes`);
+        }
+        resolved.push(item);
+    }
+    return resolved;
+}
+async function resolveMediaBlock(block, options) {
     const bounds = options.bounds ?? {};
     const maxItemBytes = bounds.maxItemBytes ?? DEFAULT_MAX_MEDIA_ITEM_BYTES;
-    const maxAudioDurationMs = bounds.maxAudioDurationMs ?? DEFAULT_MAX_AUDIO_DURATION_MS;
-    assertMediaBlocksWithinBounds([block], bounds);
     const source = mediaSourceKind(block);
     let bytes;
     let mediaType = declaredMediaType(block);
@@ -180,6 +202,8 @@ export async function resolveMediaContentBlock(block, options = {}) {
             timeoutMs: bounds.fetchTimeoutMs ?? DEFAULT_MEDIA_FETCH_TIMEOUT_MS,
             ssrf: options.ssrf,
             fetch: options.fetch,
+            resolveHostname: options.resolveHostname,
+            requestUrl: options.requestUrl,
             signal: options.signal,
         });
     }
@@ -189,9 +213,6 @@ export async function resolveMediaContentBlock(block, options = {}) {
         mediaType = sniffed;
     }
     const durationMs = block.type === "audio" ? block.durationMs : undefined;
-    if (durationMs !== undefined && durationMs > maxAudioDurationMs) {
-        throw new MediaContentError("audio_too_long", `Audio duration ${durationMs}ms exceeded ${maxAudioDurationMs}ms`);
-    }
     return {
         mediaType,
         bytes,
@@ -283,54 +304,28 @@ function decodeBase64Bounded(data, maxBytes) {
 }
 async function fetchBoundedMediaUrl(url, options) {
     assertSsrfAllowedUrl(url, options.ssrf);
-    const fetchFn = options.fetch ?? globalThis.fetch;
-    if (!fetchFn) {
-        throw new MediaContentError("fetch_failed", "No fetch implementation available for media URL resolution");
-    }
     const timeoutController = new AbortController();
     const timeout = setTimeout(() => timeoutController.abort(), options.timeoutMs);
     const signal = options.signal
         ? AbortSignal.any([options.signal, timeoutController.signal])
         : timeoutController.signal;
     try {
-        const response = await fetchFn(url, { signal, redirect: "error" });
-        if (!response.ok) {
-            throw new MediaContentError("fetch_failed", `Media fetch failed with status ${response.status}`);
-        }
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new MediaContentError("fetch_failed", "Media fetch returned no response body");
-        }
-        const chunks = [];
-        let total = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                if (!value)
-                    continue;
-                total += value.byteLength;
-                if (total > options.maxBytes) {
-                    throw new MediaContentError("item_too_large", `Fetched media exceeded ${options.maxBytes} bytes`);
-                }
-                chunks.push(value);
-            }
-        }
-        finally {
-            try {
-                await reader.cancel();
-            }
-            catch {
-                // Reader may already be closed after abort/complete.
-            }
-            reader.releaseLock();
-        }
-        const bytes = new Uint8Array(total);
-        let offset = 0;
-        for (const chunk of chunks) {
-            bytes.set(chunk, offset);
-            offset += chunk.byteLength;
+        if (options.fetch)
+            return await readFetchResponse(await options.fetch(url, { signal, redirect: "error" }), options.maxBytes);
+        const parsed = new URL(url);
+        const hostname = normalizeHostname(parsed.hostname);
+        const family = isIP(hostname);
+        const address = family
+            ? { address: hostname, family: family }
+            : await resolvePublicAddress(hostname, options.resolveHostname ?? defaultMediaHostnameResolver, signal, options.ssrf);
+        const bytes = await (options.requestUrl ?? requestPinnedMediaUrl)({
+            url: parsed,
+            address,
+            maxBytes: options.maxBytes,
+            signal,
+        });
+        if (bytes.byteLength > options.maxBytes) {
+            throw new MediaContentError("item_too_large", `Fetched media exceeded ${options.maxBytes} bytes`);
         }
         return bytes;
     }
@@ -348,6 +343,110 @@ async function fetchBoundedMediaUrl(url, options) {
         clearTimeout(timeout);
     }
 }
+async function defaultMediaHostnameResolver(hostname) {
+    return dnsLookup(hostname, { all: true, verbatim: true });
+}
+async function resolvePublicAddress(hostname, resolver, signal, policy) {
+    const addresses = await raceAbort(resolver(hostname, signal), signal);
+    if (addresses.length === 0)
+        throw new MediaContentError("fetch_failed", "Media hostname resolved to no addresses");
+    if (addresses.length > 32)
+        throw new MediaContentError("fetch_failed", "Media hostname resolved to too many addresses");
+    if (policy?.denyPrivateHosts !== false && !policy?.allowedHostnames?.length) {
+        if (addresses.some(({ address }) => isBlockedIp(normalizeHostname(address)))) {
+            throw new MediaContentError("ssrf_denied", `Media URL host ${hostname} resolved to a private address`);
+        }
+    }
+    const selected = addresses[0];
+    if (isIP(normalizeHostname(selected.address)) !== selected.family) {
+        throw new MediaContentError("fetch_failed", "Media hostname resolver returned an invalid address");
+    }
+    return { address: normalizeHostname(selected.address), family: selected.family };
+}
+async function raceAbort(promise, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => signal.removeEventListener("abort", onAbort);
+        const onAbort = () => {
+            cleanup();
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => { cleanup(); resolve(value); }, (error) => { cleanup(); reject(error); });
+    });
+}
+async function readFetchResponse(response, maxBytes) {
+    if (!response.ok)
+        throw new MediaContentError("fetch_failed", `Media fetch failed with status ${response.status}`);
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new MediaContentError("fetch_failed", "Media fetch returned no response body");
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            total += value.byteLength;
+            if (total > maxBytes)
+                throw new MediaContentError("item_too_large", `Fetched media exceeded ${maxBytes} bytes`);
+            chunks.push(value);
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Reader may already be closed after abort/complete.
+        }
+        reader.releaseLock();
+    }
+    return joinChunks(chunks, total);
+}
+function requestPinnedMediaUrl({ url, address, maxBytes, signal }) {
+    return new Promise((resolve, reject) => {
+        const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
+            agent: false,
+            family: address.family,
+            signal,
+            lookup: (_hostname, _options, callback) => callback(null, address.address, address.family),
+        }, (response) => readIncomingMessage(response, maxBytes).then(resolve, reject));
+        request.on("error", reject);
+        request.end();
+    });
+}
+async function readIncomingMessage(response, maxBytes) {
+    const status = response.statusCode ?? 0;
+    if (status < 200 || status >= 300) {
+        response.resume();
+        throw new MediaContentError("fetch_failed", `Media fetch failed with status ${status}`);
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of response) {
+        const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+        total += bytes.byteLength;
+        if (total > maxBytes) {
+            response.destroy();
+            throw new MediaContentError("item_too_large", `Fetched media exceeded ${maxBytes} bytes`);
+        }
+        chunks.push(bytes);
+    }
+    return joinChunks(chunks, total);
+}
+function joinChunks(chunks, total) {
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
 function mediaTypesCompatible(declared, sniffed) {
     const normalizedDeclared = declared.toLowerCase();
     const normalizedSniffed = sniffed.toLowerCase();
@@ -365,33 +464,62 @@ function mediaTypesCompatible(declared, sniffed) {
         return true;
     return false;
 }
+function normalizeHostname(hostname) {
+    const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    return normalized.endsWith(".") ? normalized.slice(0, -1) : normalized;
+}
 function isBlockedIp(hostname) {
-    if (hostname.includes(":"))
-        return isBlockedIpv6(hostname);
-    const parts = hostname.split(".").map((part) => Number(part));
-    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-        return false;
-    }
-    const [a, b] = parts;
-    if (a === 127 || a === 10 || a === 0)
-        return true;
-    if (a === 169 && b === 254)
+    const normalized = normalizeHostname(hostname);
+    const family = isIP(normalized);
+    if (family === 4)
+        return isBlockedIpv4(normalized);
+    if (family === 6)
+        return isBlockedIpv6(normalized);
+    return false;
+}
+function isBlockedIpv4(address) {
+    const [a, b] = address.split(".").map(Number);
+    return a === 0
+        || a === 10
+        || a === 127
+        || (a === 100 && b >= 64 && b <= 127)
+        || (a === 169 && b === 254)
+        || (a === 172 && b >= 16 && b <= 31)
+        || (a === 192 && (b === 0 || b === 168))
+        || (a === 198 && (b === 18 || b === 19 || b === 51))
+        || (a === 203 && b === 0)
+        || a >= 224;
+}
+function isBlockedIpv6(address) {
+    const words = parseIpv6Words(address);
+    if (!words)
         return true;
-    if (a === 192 && b === 168)
+    if (words.every((word) => word === 0) || words.slice(0, 7).every((word) => word === 0) && words[7] === 1)
         return true;
-    if (a === 172 && b !== undefined && b >= 16 && b <= 31)
+    if ((words[0] & 0xfe00) === 0xfc00)
         return true;
-    return false;
-}
-function isBlockedIpv6(hostname) {
-    const normalized = hostname.toLowerCase();
-    if (normalized === "::1")
+    if ((words[0] & 0xffc0) === 0xfe80 || (words[0] & 0xffc0) === 0xfec0)
         return true;
-    if (normalized.startsWith("fc") || normalized.startsWith("fd"))
+    if ((words[0] & 0xff00) === 0xff00)
         return true;
-    if (normalized.startsWith("fe80:"))
+    if (words[0] === 0x2001 && words[1] === 0x0db8)
         return true;
-    return false;
+    const mapped = words.slice(0, 5).every((word) => word === 0) && (words[5] === 0 || words[5] === 0xffff);
+    return mapped && isBlockedIpv4(`${words[6] >> 8}.${words[6] & 0xff}.${words[7] >> 8}.${words[7] & 0xff}`);
+}
+function parseIpv6Words(address) {
+    const parts = address.split("::");
+    if (parts.length > 2)
+        return undefined;
+    const left = parts[0] ? parts[0].split(":") : [];
+    const right = parts[1] ? parts[1].split(":") : [];
+    const missing = 8 - left.length - right.length;
+    if (missing < 0 || (parts.length === 1 && missing !== 0))
+        return undefined;
+    const words = [...left, ...Array.from({ length: missing }, () => "0"), ...right].map((part) => Number.parseInt(part, 16));
+    return words.length === 8 && words.every((word) => Number.isInteger(word) && word >= 0 && word <= 0xffff)
+        ? words
+        : undefined;
 }
 function startsWith(bytes, prefix) {
     if (bytes.length < prefix.length)

package/dist/contracts.d.ts

@@ -256,13 +256,7 @@ export interface AgentConfig {
     readonly promptBuilder?: PromptBuilder;
     readonly middleware?: MiddlewareRegistry;
     readonly resourceLoader?: ResourceLoader;
-    /** Host-owned metadata only: createAgent/session.run do not load or run these extensions. */
-    readonly extensions?: readonly Extension[];
     readonly store?: SessionStore;
-    /** Host-owned metadata only: createAgent/session.run do not read settings. */
-    readonly settings?: SettingsProvider;
-    /** Host-owned metadata only: createAgent/session.run do not resolve credentials. Pass resolvers to provider edges explicitly. */
-    readonly credentials?: CredentialResolver;
     readonly permission?: PermissionPolicy;
     readonly providerOptions?: ProviderRequestOptions;
     readonly providerRequestPolicies?: ProviderRequestPolicy | readonly ProviderRequestPolicy[];
@@ -304,13 +298,42 @@ export interface SubscribeOptions {
     /** What to do when `maxQueuedEvents` is reached. Defaults to `close`. */
     readonly overflow?: SubscriberOverflowPolicy;
 }
+export type AgentRunStatus = "succeeded" | "failed" | "aborted";
+/** Terminal result of `session.run()` / `session.prompt()`. Failed and aborted runs throw {@link AgentRunError} with this shape attached. */
+export interface AgentRunResult {
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly status: AgentRunStatus;
+    /** Branch leaf after the run settles. */
+    readonly leafId?: string;
+    /** Concatenated text blocks from the final assistant message, or `""` when none. */
+    readonly text: string;
+    /** Content blocks from the final assistant message, or `[]` when none. */
+    readonly content: readonly ContentBlock[];
+    /** Final assistant message when the run produced one. */
+    readonly message?: Message;
+    /** Aggregate usage across provider turns (`run_total` scope). */
+    readonly usage?: Usage;
+    /** Present when `status` is `"failed"` or when a failed attempt still produced partial output. */
+    readonly error?: ErrorInfo;
+    /** String form of the abort reason when `status` is `"aborted"`. */
+    readonly abortReason?: string;
+}
+export declare class AgentRunError extends Error {
+    readonly result: AgentRunResult;
+    constructor(result: AgentRunResult, options?: {
+        readonly cause?: unknown;
+    });
+}
 export interface AgentSession {
     readonly id: string;
     /** Current branch leaf entry id; advances on every append/run and is re-pointed by `checkout`.
      *  Undefined until the first entry lands (a fresh session with no history). */
     readonly leafId: string | undefined;
-    run(input: string | Message | readonly Message[], options?: RunOptions): Promise<void>;
-    prompt(input: string, options?: RunOptions): Promise<void>;
+    run(input: string | Message | readonly Message[], options?: RunOptions): Promise<AgentRunResult>;
+    prompt(input: string, options?: RunOptions): Promise<AgentRunResult>;
+    /** Subscribe first, then start exactly one run and yield only that run's events until it terminates. */
+    stream(input: string | Message | readonly Message[], options?: RunOptions & SubscribeOptions): AsyncIterable<AgentEvent>;
     compact(options?: CompactionOptions): Promise<CompactionResult>;
     subscribe(options?: SubscribeOptions): AsyncIterable<AgentEvent>;
     abort(reason?: unknown): void;
@@ -1035,12 +1058,16 @@ export interface ToolCallRecord extends OwnershipScope {
     readonly redacted: boolean;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-/** Stored usage row. */
+export type UsageScope = "provider_turn" | "run_total";
+/** Stored usage row. `scope` prevents provider-turn and aggregate totals from being summed together. */
 export interface UsageRecord extends OwnershipScope {
     readonly id: string;
     readonly sessionId: string;
     readonly runId?: string;
     readonly entryId?: string;
+    readonly scope: UsageScope;
+    readonly turn?: number;
+    readonly attempt?: number;
     readonly usage: Usage;
     readonly recordedAt: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
@@ -1054,6 +1081,59 @@ export interface RunLedger {
 }
 /** Union of records that may be handed to a {@link RunLedger}. */
 export type RunLedgerRecord = RunRecord | AgentEventRecord | ToolCallRecord | UsageRecord;
+/** Immutable human feedback linked to an existing owned run/trace and optional evaluations. */
+export interface RunFeedbackRecord extends OwnershipScope {
+    readonly id: string;
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly traceId?: string;
+    readonly rating?: number;
+    readonly comment?: string;
+    readonly tags: readonly string[];
+    readonly scorerIds: readonly string[];
+    readonly evaluationIds: readonly string[];
+    readonly createdAt: string;
+    readonly createdBy?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface AppendRunFeedbackInput extends OwnershipScope {
+    readonly id: string;
+    readonly runId: string;
+    readonly sessionId?: string;
+    readonly traceId?: string;
+    readonly rating?: number;
+    readonly comment?: string;
+    readonly tags?: readonly string[];
+    readonly scorerIds?: readonly string[];
+    readonly evaluationIds?: readonly string[];
+    readonly createdAt?: string;
+    readonly createdBy?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+/** Cursor-paginated, ownership-scoped feedback query. */
+export interface RunFeedbackQuery extends PersistenceQuery, OwnershipScope {
+    readonly runId?: string;
+    readonly sessionId?: string;
+    readonly traceId?: string;
+    readonly rating?: number;
+    readonly scorerId?: string;
+    readonly evaluationId?: string;
+    readonly tag?: string;
+    readonly fromCreatedAt?: string;
+    readonly toCreatedAt?: string;
+    readonly signal?: AbortSignal;
+}
+export interface DeleteRunFeedbackInput extends OwnershipScope {
+    readonly id: string;
+    readonly signal?: AbortSignal;
+}
+/** Feedback storage seam. Records are append-only; correction uses a new record and deletion is explicit. */
+export interface RunFeedbackStore {
+    append(input: AppendRunFeedbackInput): Promise<RunFeedbackRecord>;
+    query(query: RunFeedbackQuery): Promise<PersistencePage<RunFeedbackRecord>>;
+    delete(input: DeleteRunFeedbackInput): Promise<boolean>;
+}
 /** Stored agent definition version. Does not include provider credentials/resolvers/provider instances. */
 export interface AgentDefinitionRecord extends OwnershipScope {
     readonly id: string;
@@ -1158,6 +1238,9 @@ export interface UsageQuery extends PersistenceQuery, OwnershipScope {
     readonly sessionId?: string;
     readonly runId?: string;
     readonly entryId?: string;
+    readonly scope?: UsageScope;
+    readonly turn?: number;
+    readonly attempt?: number;
     readonly fromRecordedAt?: string;
     readonly toRecordedAt?: string;
 }
@@ -1194,6 +1277,8 @@ export interface ProductionPersistenceStore {
     readonly checkpoints?: CheckpointStore;
     /** Optional atomic distributed lease capability for coordinators and workers. */
     readonly leases?: LeaseStore;
+    /** Optional immutable run/trace feedback storage capability. */
+    readonly feedback?: RunFeedbackStore;
     querySessions(query: SessionQuery): Promise<PersistencePage<SessionRecord>>;
     queryBranches(query: BranchQuery): Promise<PersistencePage<BranchRecord>>;
     queryEntries(query: SessionEntryQuery): Promise<PersistencePage<SessionEntry>>;

package/dist/contracts.js

@@ -1,3 +1,11 @@
+export class AgentRunError extends Error {
+    result;
+    constructor(result, options) {
+        super(result.error?.message ?? (result.status === "aborted" ? "Agent run aborted" : "Agent run failed"), options);
+        this.name = "AgentRunError";
+        this.result = result;
+    }
+}
 export const SESSION_ENTRY_KINDS = [
     "message",
     "event",

package/dist/feedback.d.ts

@@ -0,0 +1,48 @@
+import type { AppendRunFeedbackInput, OwnershipScope, RunFeedbackRecord, RunFeedbackStore } from "./contracts.js";
+import type { SecretRedactor } from "./redaction.js";
+export declare const DEFAULT_MAX_FEEDBACK_COMMENT_BYTES = 4096;
+export declare const HARD_MAX_FEEDBACK_COMMENT_BYTES = 16384;
+export declare const DEFAULT_MAX_FEEDBACK_TAGS = 16;
+export declare const HARD_MAX_FEEDBACK_TAGS = 64;
+export declare const DEFAULT_MAX_FEEDBACK_LINKS = 16;
+export declare const HARD_MAX_FEEDBACK_LINKS = 64;
+export declare const DEFAULT_MAX_FEEDBACK_METADATA_BYTES = 16384;
+export declare const HARD_MAX_FEEDBACK_METADATA_BYTES = 65536;
+export declare const DEFAULT_FEEDBACK_PAGE_SIZE = 100;
+export declare const HARD_FEEDBACK_PAGE_SIZE = 500;
+export declare const MAX_FEEDBACK_TAG_LENGTH = 64;
+export declare const MAX_FEEDBACK_ID_LENGTH = 128;
+export declare class RunFeedbackError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+export interface RunFeedbackRun extends OwnershipScope {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly traceId?: string;
+}
+export type RunFeedbackRunResolver = (input: Readonly<{
+    runId: string;
+    ownership: OwnershipScope;
+    signal?: AbortSignal;
+}>) => RunFeedbackRun | false | undefined | Promise<RunFeedbackRun | false | undefined>;
+export interface RunFeedbackLimits {
+    readonly maxCommentBytes?: number;
+    readonly maxTags?: number;
+    readonly maxLinks?: number;
+    readonly maxMetadataBytes?: number;
+    readonly maxPageSize?: number;
+}
+export interface PrepareRunFeedbackOptions extends RunFeedbackLimits {
+    readonly resolveRun: RunFeedbackRunResolver;
+    readonly redactor?: SecretRedactor;
+}
+export interface MemoryRunFeedbackStoreOptions extends PrepareRunFeedbackOptions {
+    readonly initial?: readonly RunFeedbackRecord[];
+}
+/** Validate, ownership-check, redact, bound, and freeze one feedback record. */
+export declare function prepareRunFeedback(input: AppendRunFeedbackInput, options: PrepareRunFeedbackOptions): Promise<RunFeedbackRecord>;
+/** In-memory implementation with the same validation/ownership semantics as durable adapters. */
+export declare function createMemoryRunFeedbackStore(options: MemoryRunFeedbackStoreOptions): RunFeedbackStore;
+export declare function requireRunFeedbackOwnership(input: OwnershipScope): Required<Pick<OwnershipScope, "tenantId">> & OwnershipScope;
+export declare function runFeedbackPageLimit(limit: number | undefined, maximum?: number): number;