@arnilo/prism 0.0.3 → 0.0.5

package/dist/providers/transport.js

@@ -0,0 +1,221 @@
+import { redactSecrets } from "../redaction.js";
+export const DEFAULT_MAX_EVENT_BYTES = 262_144;
+export const DEFAULT_MAX_BUFFER_BYTES = 524_288;
+export const DEFAULT_MAX_RESPONSE_BODY_BYTES = 65_536;
+export const DEFAULT_MAX_ARGUMENT_BYTES = 262_144;
+export class ProviderTransportError extends Error {
+    code;
+    limitBytes;
+    constructor(code, message, limitBytes) {
+        super(message);
+        this.name = "ProviderTransportError";
+        this.code = code;
+        this.limitBytes = limitBytes;
+    }
+}
+function resolveLimits(options) {
+    return {
+        maxEventBytes: options?.maxEventBytes ?? DEFAULT_MAX_EVENT_BYTES,
+        maxBufferBytes: options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES,
+        maxResponseBodyBytes: options?.maxResponseBodyBytes ?? DEFAULT_MAX_RESPONSE_BODY_BYTES,
+    };
+}
+function byteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new ProviderTransportError("aborted", "Transport operation aborted");
+    }
+}
+function parseSseEventBlock(block) {
+    const comments = [];
+    const dataLines = [];
+    let id;
+    let event;
+    for (const line of block.split(/\r?\n/)) {
+        if (!line)
+            continue;
+        if (line.startsWith(":")) {
+            comments.push(line.slice(1).trimStart());
+            continue;
+        }
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^\s/, "");
+        switch (field) {
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                id = value;
+                break;
+            case "event":
+                event = value;
+                break;
+            default:
+                break;
+        }
+    }
+    const data = dataLines.join("\n");
+    if (!data && comments.length === 0)
+        return undefined;
+    return {
+        id,
+        event,
+        data,
+        ...(comments.length > 0 ? { comments } : {}),
+    };
+}
+function eventBlockBytes(block) {
+    return byteLength(block);
+}
+/** Incremental O(bytes) SSE parser with finite buffer/event limits. */
+export async function* readSseEvents(body, options) {
+    const limits = resolveLimits(options);
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const ensureBufferLimit = () => {
+        if (byteLength(buffer) > limits.maxBufferBytes) {
+            throw new ProviderTransportError("sse_buffer_overflow", `SSE buffer exceeded ${limits.maxBufferBytes} bytes`, limits.maxBufferBytes);
+        }
+    };
+    const yieldCompleteEvents = function* () {
+        while (true) {
+            const match = buffer.match(/\r?\n\r?\n/);
+            if (!match || match.index === undefined)
+                break;
+            const block = buffer.slice(0, match.index);
+            buffer = buffer.slice(match.index + match[0].length);
+            const parsed = parseSseEventBlock(block);
+            if (!parsed)
+                continue;
+            const size = eventBlockBytes(block);
+            if (size > limits.maxEventBytes) {
+                throw new ProviderTransportError("sse_event_overflow", `SSE event exceeded ${limits.maxEventBytes} bytes`, limits.maxEventBytes);
+            }
+            yield parsed;
+        }
+    };
+    try {
+        while (true) {
+            throwIfAborted(options?.signal);
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            ensureBufferLimit();
+            yield* yieldCompleteEvents();
+        }
+        buffer += decoder.decode();
+        ensureBufferLimit();
+        yield* yieldCompleteEvents();
+        const tail = buffer.trim();
+        if (tail) {
+            const parsed = parseSseEventBlock(tail);
+            if (parsed) {
+                const size = eventBlockBytes(tail);
+                if (size > limits.maxEventBytes) {
+                    throw new ProviderTransportError("sse_event_overflow", `SSE event exceeded ${limits.maxEventBytes} bytes`, limits.maxEventBytes);
+                }
+                yield parsed;
+            }
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // already released
+        }
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // stream may already be closed
+        }
+    }
+}
+/** Yields joined `data:` payloads for each SSE event (migration helper over {@link readSseEvents}). */
+export async function* readSseData(body, options) {
+    for await (const event of readSseEvents(body, options)) {
+        const data = event.data.trim();
+        if (data)
+            yield data;
+    }
+}
+/** Read a response body with a hard byte ceiling; redacts optional secrets. */
+export async function readBoundedResponseText(response, options) {
+    const limits = resolveLimits(options);
+    const secrets = options?.secrets ?? [];
+    if (!response.body) {
+        try {
+            const text = await response.text();
+            if (byteLength(text) > limits.maxResponseBodyBytes) {
+                throw new ProviderTransportError("response_body_overflow", `Response body exceeded ${limits.maxResponseBodyBytes} bytes`, limits.maxResponseBodyBytes);
+            }
+            return redactSecrets(text, secrets);
+        }
+        catch (error) {
+            if (error instanceof ProviderTransportError)
+                throw error;
+            return "";
+        }
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const parts = [];
+    let totalBytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            totalBytes += value.byteLength;
+            if (totalBytes > limits.maxResponseBodyBytes) {
+                throw new ProviderTransportError("response_body_overflow", `Response body exceeded ${limits.maxResponseBodyBytes} bytes`, limits.maxResponseBodyBytes);
+            }
+            parts.push(decoder.decode(value, { stream: true }));
+        }
+        parts.push(decoder.decode());
+        return redactSecrets(parts.join(""), secrets);
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // already released
+        }
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // stream may already be closed
+        }
+    }
+}
+/** Parse streamed tool arguments as a JSON object; throws {@link ProviderTransportError} on invalid input. */
+export function parseJsonObjectArguments(text, options) {
+    const maxBytes = options?.maxBytes ?? DEFAULT_MAX_ARGUMENT_BYTES;
+    const suffix = options?.toolName ? ` for tool ${options.toolName}` : "";
+    if (!text)
+        return {};
+    if (byteLength(text) > maxBytes) {
+        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} exceeded ${maxBytes} bytes`, maxBytes);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new ProviderTransportError("invalid_json_arguments", `Invalid tool arguments JSON${suffix}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new ProviderTransportError("invalid_json_arguments", `Tool arguments${suffix} must be a JSON object`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=transport.js.map

package/dist/redaction.js

@@ -22,10 +22,25 @@ export function redactSecrets(value, secrets) {
     if (needles.length === 0)
         return value;
     const redactString = (text) => needles.reduce((current, secret) => current.split(secret).join(REDACTED), text);
-    // ponytail: WeakSet cycle guard + leaf passthrough for Date/RegExp/ArrayBuffer/typed
-    // arrays. Map/Set are normalized to plain object/array so output stays JSON-shaped.
-    // Upgrade path: if callers need original Map/Set preserved, thread a mode flag.
-    const redact = (input, seen = new WeakSet()) => {
+    const redactKey = (key) => {
+        if (typeof key === "string")
+            return redactString(key);
+        return String(key);
+    };
+    const assignKey = (target, key, value) => {
+        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+            target[key] = value;
+            return;
+        }
+        let suffix = 2;
+        while (Object.prototype.hasOwnProperty.call(target, `${key}__${suffix}`))
+            suffix += 1;
+        target[`${key}__${suffix}`] = value;
+    };
+    // ponytail: active-path WeakSet marks only ancestor cycles as [Circular]; shared
+    // references (diamonds) are visited again on separate branches. Map/Set normalize
+    // to JSON-shaped output; string keys are redacted like values.
+    const redact = (input, active = new WeakSet()) => {
         if (typeof input === "string")
             return redactString(input);
         if (input === null || typeof input !== "object")
@@ -34,16 +49,28 @@ export function redactSecrets(value, secrets) {
             return input;
         if (ArrayBuffer.isView(input) || input instanceof ArrayBuffer)
             return input;
-        if (seen.has(input))
+        if (active.has(input))
             return "[Circular]";
-        seen.add(input);
-        if (Array.isArray(input))
-            return input.map((item) => redact(item, seen));
-        if (input instanceof Map)
-            return Object.fromEntries([...input].map(([key, item]) => [key, redact(item, seen)]));
-        if (input instanceof Set)
-            return [...input].map((item) => redact(item, seen));
-        return Object.fromEntries(Object.entries(input).map(([key, item]) => [key, redact(item, seen)]));
+        active.add(input);
+        try {
+            if (Array.isArray(input))
+                return input.map((item) => redact(item, active));
+            if (input instanceof Map) {
+                const out = {};
+                for (const [key, item] of input)
+                    assignKey(out, redactKey(key), redact(item, active));
+                return out;
+            }
+            if (input instanceof Set)
+                return [...input].map((item) => redact(item, active));
+            const out = {};
+            for (const [key, item] of Object.entries(input))
+                assignKey(out, redactKey(key), redact(item, active));
+            return out;
+        }
+        finally {
+            active.delete(input);
+        }
     };
     return redact(value);
 }

package/dist/resources.d.ts

@@ -1,5 +1,10 @@
 import { type PrismManifest } from "./manifests.js";
 import type { JsonObject, ResourceLoader, ResourceLoadContext } from "./contracts.js";
+import { type MediaContentBounds } from "./content.js";
 export declare function loadTextResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<string>;
 export declare function loadJsonResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<JsonObject>;
 export declare function loadManifestResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<PrismManifest>;
+export interface LoadBinaryResourceOptions extends MediaContentBounds {
+    readonly signal?: AbortSignal;
+}
+export declare function loadBinaryResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext, options?: LoadBinaryResourceOptions): Promise<Uint8Array>;

package/dist/resources.js

@@ -1,5 +1,6 @@
 import { parsePrismManifest } from "./manifests.js";
 import { assertJsonObject } from "./config.js";
+import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource, } from "./content.js";
 import { assertPermission } from "./security.js";
 export async function loadTextResource(loader, uri, context) {
     await assertPermission(context?.permission, { kind: "resource", action: "load", target: uri, metadata: context?.metadata });
@@ -24,6 +25,9 @@ export async function loadJsonResource(loader, uri, context) {
 export async function loadManifestResource(loader, uri, context) {
     return parsePrismManifest(await loadJsonResource(loader, uri, context));
 }
+export async function loadBinaryResource(loader, uri, context, options) {
+    return loadBoundedBinaryResource(loader, uri, context, options?.maxItemBytes ?? DEFAULT_MAX_MEDIA_ITEM_BYTES, options?.signal ?? context?.signal);
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/structured-output.d.ts

@@ -0,0 +1,11 @@
+import type { AgentConfig, ModelCapabilities, ModelConfig, ProviderRequestOptions, RunOptions, StructuredOutputOptions } from "./contracts.js";
+export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES = 65536;
+export declare const DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH = 128;
+export declare class StructuredOutputError extends Error {
+    readonly code: "invalid_schema" | "unsupported_model" | "schema_too_large" | "invalid_name";
+    constructor(code: StructuredOutputError["code"], message: string);
+}
+export declare function modelSupportsStructuredOutput(capabilities?: ModelCapabilities): boolean;
+export declare function validateStructuredOutputOptions(options: StructuredOutputOptions): StructuredOutputOptions;
+export declare function assertStructuredOutputRequestSupported(model: ModelConfig, options?: ProviderRequestOptions): void;
+export declare function resolveRunProviderOptions(runOptions: Pick<RunOptions, "providerOptions" | "loop">, config: Pick<AgentConfig, "providerOptions" | "loop">): ProviderRequestOptions | undefined;

package/dist/structured-output.js

@@ -0,0 +1,59 @@
+import { assertJsonObject } from "./config.js";
+import { mergeProviderRequestOptions } from "./provider-request-policy.js";
+export const DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES = 65_536;
+export const DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH = 128;
+export class StructuredOutputError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "StructuredOutputError";
+        this.code = code;
+    }
+}
+export function modelSupportsStructuredOutput(capabilities) {
+    const mode = capabilities?.structuredOutput;
+    return mode === true || mode === "json_schema";
+}
+export function validateStructuredOutputOptions(options) {
+    const name = options.name.trim();
+    if (!name)
+        throw new StructuredOutputError("invalid_name", "structuredOutput.name is required");
+    if (name.length > DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH) {
+        throw new StructuredOutputError("invalid_name", `structuredOutput.name exceeded ${DEFAULT_MAX_STRUCTURED_OUTPUT_NAME_LENGTH} characters`);
+    }
+    try {
+        assertJsonObject(options.schema, "structuredOutput.schema");
+    }
+    catch (error) {
+        throw new StructuredOutputError("invalid_schema", error instanceof Error ? error.message : "structuredOutput.schema must be a JSON object");
+    }
+    const schemaBytes = new TextEncoder().encode(JSON.stringify(options.schema)).byteLength;
+    if (schemaBytes > DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES) {
+        throw new StructuredOutputError("schema_too_large", `structuredOutput.schema exceeded ${DEFAULT_MAX_STRUCTURED_OUTPUT_SCHEMA_BYTES} bytes`);
+    }
+    return { ...options, name, schema: options.schema };
+}
+export function assertStructuredOutputRequestSupported(model, options) {
+    if (!options?.structuredOutput)
+        return;
+    validateStructuredOutputOptions(options.structuredOutput);
+    if (!modelSupportsStructuredOutput(model.capabilities)) {
+        throw new StructuredOutputError("unsupported_model", `Model ${model.provider}/${model.model} does not declare structuredOutput capability; `
+            + `set loop.structuredOutputMode to "artifact-loop" or choose a capable model`);
+    }
+}
+function isGenerateValidateReviseLoopOptions(loop) {
+    return typeof loop === "object" && loop !== null && "strategy" in loop && loop.strategy === "generate-validate-revise";
+}
+export function resolveRunProviderOptions(runOptions, config) {
+    const merged = mergeProviderRequestOptions(config.providerOptions, runOptions.providerOptions);
+    const loop = runOptions.loop ?? config.loop;
+    if (!isGenerateValidateReviseLoopOptions(loop))
+        return merged;
+    if (loop.structuredOutputMode === "artifact-loop" || !loop.structuredOutput)
+        return merged;
+    return mergeProviderRequestOptions(merged, {
+        structuredOutput: validateStructuredOutputOptions(loop.structuredOutput),
+    });
+}
+//# sourceMappingURL=structured-output.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

@@ -0,0 +1,102 @@
+import type { PersistencePage, SessionEntry, SessionEntryQuery } from "../contracts.js";
+/** Current shared persistence schema version for production database adapters. */
+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;
+    /** Column participates in tenant isolation boundaries when true. */
+    readonly tenantScoped?: boolean;
+}
+export interface PersistenceForeignKeyDefinition {
+    readonly columns: readonly string[];
+    readonly referencesTable: PersistenceTableName;
+    readonly referencesColumns: readonly string[];
+    /** When true, tenant_id must participate in the FK boundary for scoped tables. */
+    readonly tenantBound?: boolean;
+}
+export interface PersistenceTableDefinition {
+    readonly name: PersistenceTableName;
+    readonly columns: readonly PersistenceColumnDefinition[];
+    readonly primaryKey: readonly string[];
+    readonly uniqueKeys?: readonly (readonly string[])[];
+    readonly foreignKeys?: readonly PersistenceForeignKeyDefinition[];
+}
+export interface PersistenceIndexDefinition {
+    readonly name: string;
+    readonly table: PersistenceTableName;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    /** Human-readable query-plan purpose for adapter authors and tests. */
+    readonly purpose: string;
+}
+/** Dialect-neutral schema model shared by SQLite and PostgreSQL adapters. */
+export interface PersistenceSchemaModel {
+    readonly version: number;
+    readonly tables: readonly PersistenceTableDefinition[];
+    readonly indexes: readonly PersistenceIndexDefinition[];
+}
+export interface PersistenceMigrationStep {
+    readonly version: number;
+    readonly name: string;
+    readonly description?: string;
+}
+/** Versioned migration expectations shared by production database adapters. */
+export interface PersistenceMigrationContract {
+    readonly targetSchemaVersion: number;
+    readonly appliedMigrationsTable: PersistenceTableName;
+    readonly steps: readonly PersistenceMigrationStep[];
+    /** Advisory-lock or equivalent guidance for concurrent migration setup. */
+    readonly lockGuidance: string;
+    /** Least-privilege role guidance for migration vs runtime credentials. */
+    readonly leastPrivilegeGuidance: string;
+}
+/** Cursor key shapes adapters must index so pagination avoids full scans. */
+export interface PersistencePaginationCursor {
+    readonly table: PersistenceTableName;
+    readonly columns: readonly string[];
+    readonly supportsOrder: readonly ("asc" | "desc")[];
+    readonly purpose: string;
+}
+/** Guidance adapters must follow: values are bound parameters, never interpolated. */
+export declare const PARAMETERIZED_QUERY_GUIDANCE = "Bind every user-supplied value (session ids, idempotency keys, tenant ids, timestamps, JSON payloads) as a query parameter. Quote/validate schema and table identifiers only; never interpolate untrusted strings into SQL text.";
+/** Canonical shared schema model for Tasks 2–3 adapter packages. */
+export declare function createPersistenceSchemaModel(): PersistenceSchemaModel;
+/** Canonical migration contract for production adapters. */
+export declare function createPersistenceMigrationContract(): PersistenceMigrationContract;
+/** Indexed cursor columns adapters must support for paginated reads. */
+export declare function getPersistencePaginationCursors(): readonly PersistencePaginationCursor[];
+/** Build a tenant-scoped unique key column list for adapter DDL. */
+export declare function tenantScopedUniqueKey(baseColumns: readonly string[], tenantColumn?: "tenant_id" | "account_id" | "user_id"): readonly string[];
+/** Assert a schema model includes required tables, tenant boundaries, and indexes. */
+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;
+/**
+ * Assert a dialect-local adapter exposes the canonical table and index names.
+ * Adapters pass the table/index names their migration runner created.
+ */
+export declare function assertAdapterSchemaMatchesModel(adapterTables: readonly string[], adapterIndexes: readonly string[], model?: PersistenceSchemaModel): void;
+/** 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 interface PersistenceQueryConformanceFixture {
+    readonly seedEntries: (entries: readonly SessionEntry[]) => Promise<void> | void;
+    readonly queryEntries: (query: SessionEntryQuery) => Promise<PersistencePage<SessionEntry>>;
+}
+/** Assert cursor pagination returns stable pages without repeating rows. */
+export declare function assertPersistenceQueryPaginationConforms(fixture: PersistenceQueryConformanceFixture, sessionId?: string): Promise<void>;
+/** Assert tenant-filtered queries do not return rows from another tenant. */
+export declare function assertTenantScopedQueryIsolation(queryByTenant: (tenantId: string) => Promise<readonly {
+    readonly tenantId?: string;
+    readonly id: string;
+}[]>): Promise<void>;