@arnilo/prism 0.0.3 → 0.0.5

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;

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/index.d.ts

@@ -1,6 +1,13 @@
 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";
+export { createEventMultiplexer } from "./event-multiplexer.js";
+export type { EventMultiplexer, EventMultiplexerOptions, EventOverflowInfo, EventOverflowPolicy } from "./event-multiplexer.js";
 export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, sanitizeCacheKey } from "./cache-helpers.js";
 export type { ApplyCacheControlOptions, CacheControlledContentBlock, CacheControlledMessage, CacheControlValue, CacheUsageReport } from "./cache-helpers.js";
 export { resolveAgentDefinition } from "./agent-definitions.js";
@@ -19,6 +26,8 @@ export type { ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, Ex
 export type { CredentialRecord, CredentialValueSource, MemoryCredentialStore } from "./credentials.js";
 export { createModelRegistry } from "./models.js";
 export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
+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 type { SessionCachePolicyOptions } from "./provider-request-policy.js";
 export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
@@ -26,7 +35,10 @@ 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 { loadJsonResource, loadManifestResource, loadTextResource } from "./resources.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";
 export { createMiddlewareRegistry } from "./middleware.js";
 export type { Middleware, MiddlewareHookName, MiddlewareNext, MiddlewareRegistry, MiddlewareRegistryOptions } from "./middleware.js";
@@ -44,14 +56,16 @@ export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage
 export type { SecretRedactor } from "./redaction.js";
 export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
 export type { PermissionDecision, PermissionPolicy, PermissionRequest, TrustDecision, TrustPolicy, TrustRequest } from "./security.js";
+export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
+export type { ExecutionAction, ExecutionDecision, ExecutionPolicy, ExecutionRisk } from "./execution-policy.js";
 export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
 export type { ResolveActiveSkillsOptions, SkillRegistryOptions } from "./skills.js";
 export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
 export type { ResolveInstructionInjectorsOptions } from "./instruction-injection.js";
-export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
-export type { DispatchToolCallOptions, ToolFilter, ToolFilterInput, ToolRegistryOptions, ToolValidator } from "./tools.js";
+export { createToolRegistry, dispatchToolCall, filterTools, createToolParameterValidator } from "./tools.js";
+export type { DispatchToolCallOptions, ToolArgumentValidationError, ToolArgumentValidationResult, ToolArgumentValidator, ToolFilter, ToolFilterInput, ToolParameterValidatorOptions, ToolRegistryOptions, ToolValidator, } from "./tools.js";
 export type { DuplicateRegistrationOptions, DuplicateRegistrationPolicy } from "./registry-options.js";
-export { generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, singleShotLoop } from "./agent-loops.js";
+export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop } from "./agent-loops.js";
 export declare const name = "prism";
-export declare const version = "0.0.3";
+export declare const version = "0.0.5";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,5 +1,9 @@
-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";
 export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, sanitizeCacheKey } from "./cache-helpers.js";
 export { resolveAgentDefinition } from "./agent-definitions.js";
 export { parseSkillFile, parseAgentFile } from "./contribution-parsing.js";
@@ -11,10 +15,13 @@ export { createChainedCredentialResolver, createEnvCredentialResolver, createExp
 export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
 export { createModelRegistry } from "./models.js";
 export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
+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 { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
-export { loadJsonResource, loadManifestResource, loadTextResource } from "./resources.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";
 export { assembleProviderInput, createDefaultInputBuilder, createDefaultPromptBuilder, renderPromptTemplate, resolveContextProviders } from "./input.js";
@@ -24,11 +31,12 @@ export { providerContentDelta, providerDone, providerError, providerTextDelta, p
 export { createProviderRegistry, createProviderResolver } from "./providers.js";
 export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactRunLedgerRecord, redactSecrets, redactSessionEntry } from "./redaction.js";
 export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
+export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
 export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
 export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
-export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
-export { generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, singleShotLoop } from "./agent-loops.js";
+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.3";
+export const version = "0.0.5";
 export const description = "Agent harness for AI providers, agents, sessions, and tools.";
 //# sourceMappingURL=index.js.map

package/dist/input.js

@@ -1,4 +1,5 @@
 import { redactMessage } from "./redaction.js";
+import { assertMessagesSupportModelCapabilities } from "./content.js";
 import { loadTextResource } from "./resources.js";
 import { composeSystemPrompt } from "./system-prompts.js";
 import { runInstructionInjectors } from "./instruction-injection.js";
@@ -118,6 +119,7 @@ export async function assembleProviderInput(options) {
             signal: options.signal,
         };
     const providerMessages = await promptBuilder.build({ ...promptRequest, tools: options.tools });
+    assertMessagesSupportModelCapabilities(options.model, providerMessages);
     return {
         model: options.model,
         messages: providerMessages,
@@ -232,7 +234,15 @@ function blockText(block) {
             return `${part.name}(${JSON.stringify(part.arguments)})`;
         if (part.type === "tool_call_delta")
             return `${part.name ?? "tool"}(${part.argumentsText ?? ""})`;
-        return part.url ?? part.mimeType ?? "[image]";
+        if (part.type === "image")
+            return part.url ?? part.resourceUri ?? part.mimeType ?? "[image]";
+        if (part.type === "audio")
+            return part.transcript ?? part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[audio]";
+        if (part.type === "file")
+            return part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[file]";
+        if (part.type === "document")
+            return part.transcript ?? part.name ?? part.url ?? part.resourceUri ?? part.mediaType ?? "[document]";
+        return "[content]";
     }).join("\n");
 }
 function templateValue(value) {

package/dist/leases.d.ts

@@ -0,0 +1,8 @@
+import type { LeaseStore } from "./contracts.js";
+export declare const LEASE_CONFLICT_CODE = "ERR_PRISM_LEASE_CONFLICT";
+export declare class LeaseConflictError extends Error {
+    readonly code = "ERR_PRISM_LEASE_CONFLICT";
+    constructor(message: string);
+}
+/** In-process reference implementation. Durable adapters provide cross-process exclusion. */
+export declare function createMemoryLeaseStore(): LeaseStore;

package/dist/leases.js

@@ -0,0 +1,111 @@
+export const LEASE_CONFLICT_CODE = "ERR_PRISM_LEASE_CONFLICT";
+export class LeaseConflictError extends Error {
+    code = LEASE_CONFLICT_CODE;
+    constructor(message) {
+        super(message);
+        this.name = "LeaseConflictError";
+    }
+}
+/** In-process reference implementation. Durable adapters provide cross-process exclusion. */
+export function createMemoryLeaseStore() {
+    const records = new Map();
+    return {
+        async tryAcquireLease(input) {
+            validateAcquire(input);
+            const id = keyOf(input);
+            const current = records.get(id);
+            if (current)
+                assertOwnership(input, current);
+            const now = Date.now();
+            if (current && Date.parse(current.expiresAt) > now)
+                return null;
+            const timestamp = new Date(now).toISOString();
+            const record = {
+                namespace: input.namespace,
+                key: input.key,
+                ownerId: input.ownerId,
+                token: crypto.randomUUID(),
+                fencingToken: (current?.fencingToken ?? 0) + 1,
+                acquiredAt: timestamp,
+                expiresAt: new Date(now + input.ttlMs).toISOString(),
+                updatedAt: timestamp,
+                ...ownership(input),
+            };
+            records.set(id, record);
+            return record;
+        },
+        async renewLease(input) {
+            validateClaim(input, true);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return null;
+            assertOwnership(input, current);
+            const now = Date.now();
+            if (current.ownerId !== input.ownerId || current.token !== input.token || Date.parse(current.expiresAt) <= now)
+                return null;
+            const record = {
+                ...current,
+                expiresAt: new Date(now + input.ttlMs).toISOString(),
+                updatedAt: new Date(now).toISOString(),
+            };
+            records.set(keyOf(input), record);
+            return record;
+        },
+        async releaseLease(input) {
+            validateClaim(input, false);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return false;
+            assertOwnership(input, current);
+            if (current.ownerId !== input.ownerId || current.token !== input.token)
+                return false;
+            const now = new Date().toISOString();
+            records.set(keyOf(input), { ...current, expiresAt: now, updatedAt: now });
+            return true;
+        },
+        async getLease(input) {
+            throwIfAborted(input.signal);
+            const current = records.get(keyOf(input));
+            if (!current)
+                return null;
+            assertOwnership(input, current);
+            return Date.parse(current.expiresAt) > Date.now() ? current : null;
+        },
+    };
+}
+function keyOf(input) {
+    return `${input.namespace}\0${input.key}`;
+}
+function ownership(input) {
+    return {
+        ...(input.tenantId === undefined ? {} : { tenantId: input.tenantId }),
+        ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
+        ...(input.userId === undefined ? {} : { userId: input.userId }),
+    };
+}
+function assertOwnership(expected, actual) {
+    if (expected.tenantId !== actual.tenantId || expected.accountId !== actual.accountId || expected.userId !== actual.userId) {
+        throw new LeaseConflictError("Lease ownership mismatch");
+    }
+}
+function validateKey(input) {
+    throwIfAborted(input.signal);
+    if (!input.namespace || !input.key)
+        throw new LeaseConflictError("Lease namespace and key are required");
+}
+function validateAcquire(input) {
+    validateKey(input);
+    if (!input.ownerId || !Number.isSafeInteger(input.ttlMs) || input.ttlMs < 1)
+        throw new LeaseConflictError("Lease ownerId and positive ttlMs are required");
+}
+function validateClaim(input, requireTtl) {
+    validateKey(input);
+    if (!input.ownerId || !input.token || (requireTtl && (!Number.isSafeInteger(input.ttlMs) || input.ttlMs < 1))) {
+        throw new LeaseConflictError("Lease ownerId, token, and positive ttlMs are required");
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+//# sourceMappingURL=leases.js.map

package/dist/node/agent-definitions.js

@@ -7,6 +7,7 @@ import { assertPermission, isTrusted } from "../security.js";
 import { isPathInsideReal } from "./trust.js";
 import { readOptionalFile } from "./contribution-discovery.js";
 import { createSkillRegistry } from "../skills.js";
+import { isNodeErrorCode } from "./config.js";
 const defaultInclude = {
     systemPrompt: true,
     agentPrompt: true,
@@ -329,7 +330,7 @@ async function listSubdirs(dir) {
         return out;
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return [];
         throw error;
     }
@@ -339,14 +340,11 @@ async function readOptional(read, path) {
         return await read(path);
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return undefined;
         throw error;
     }
 }
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 const NAME_RE = /^[A-Za-z0-9 _-]+$/;
 function parentDirName(path) {
     const parts = path.split(/[/\\]+/).filter(Boolean);

package/dist/node/config.d.ts

@@ -7,3 +7,4 @@ export interface NodeConfigFile {
 export declare function defaultUserConfigPath(appName?: string): string;
 export declare function readConfigFile(path: string): Promise<ConfigLayer["config"]>;
 export declare function loadConfigFiles(files: readonly NodeConfigFile[]): Promise<ConfigLayer[]>;
+export declare function isNodeErrorCode(error: unknown, code: string): boolean;

package/dist/node/config.js

@@ -11,6 +11,8 @@ export async function readConfigFile(path) {
         text = await readFile(path, "utf8");
     }
     catch (error) {
+        if (isNodeErrorCode(error, "ENOENT"))
+            throw error;
         throw new Error(`Failed to read config ${path}: ${errorMessage(error)}`);
     }
     let parsed;
@@ -35,15 +37,15 @@ export async function loadConfigFiles(files) {
             layers.push({ name: file.name, config: await readConfigFile(file.path) });
         }
         catch (error) {
-            if (file.optional && isMissingFile(error))
+            if (file.optional && isNodeErrorCode(error, "ENOENT"))
                 continue;
             throw error;
         }
     }
     return layers;
 }
-function isMissingFile(error) {
-    return error instanceof Error && error.message.includes("ENOENT");
+export function isNodeErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/node/contribution-discovery.js

@@ -4,6 +4,7 @@ import { isJsonObject } from "../config.js";
 import { assertPermission } from "../security.js";
 import { isPathInsideReal } from "./trust.js";
 import { parseSkillFile } from "../contribution-parsing.js";
+import { isNodeErrorCode } from "./config.js";
 /**
  * Discover contributions on disk. Scans the workspace `.agents/` tree only;
  * no global root. One `readdir` per kind-root; no `import()`. Inert output —
@@ -34,7 +35,7 @@ async function scanKindRoot(root, kind, options) {
         names = await readdir(kindDir);
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return []; // missing kind root is normal
         throw error;
     }
@@ -46,7 +47,7 @@ async function scanKindRoot(root, kind, options) {
             isDir = (await stat(dir)).isDirectory();
         }
         catch (error) {
-            if (isMissingFile(error))
+            if (isNodeErrorCode(error, "ENOENT"))
                 continue;
             throw error;
         }
@@ -91,14 +92,13 @@ async function readManifestEntry(dir, fallbackName, kind, origin) {
     const declaration = parseManifestDeclaration(text, path, kind, fallbackName);
     return { kind, name: declaration.name, origin, path, declaration };
 }
-// ponytail: Phase 31 — exported so the system/project prompt file loader reuses the scanner's
-// ENOENT-tolerant read instead of duplicating it. isMissingFile stays private (only readOptionalFile needs it).
+// ponytail: Phase 31 — exported so the system/project prompt file loader reuses this ENOENT-tolerant read.
 export async function readOptionalFile(path) {
     try {
         return await readFile(path, "utf8");
     }
     catch (error) {
-        if (isMissingFile(error))
+        if (isNodeErrorCode(error, "ENOENT"))
             return undefined;
         throw error;
     }
@@ -106,9 +106,6 @@ export async function readOptionalFile(path) {
 // --- Internal helpers. ---
 // ponytail: parseSkillFile/parseAgentFile live in ../contribution-parsing.ts (core, fs-free); this
 // Node module owns directory walking + manifest.json parsing only.
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
 function parseManifestDeclaration(text, path, dirKind, fallbackName) {
     let parsed;
     try {