@arnilo/prism 0.0.2 → 0.0.4

package/dist/contracts.d.ts

@@ -5,6 +5,7 @@ import type { SecretRedactor } from "./redaction.js";
 import type { PermissionPolicy } from "./security.js";
 import type { ManifestContributionDeclaration } from "./manifests.js";
 import type { ToolValidator } from "./tools.js";
+import type { AudioContent, DocumentContent, FileContent } from "./content.js";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
 export interface JsonObject {
@@ -16,7 +17,8 @@ export interface ErrorInfo {
     readonly code?: string | number;
     readonly cause?: unknown;
 }
-export type ContentBlock = TextContent | ImageContent | ThinkingContent | ToolCallDeltaContent | ToolCallContent | ToolResultContent;
+export type { AudioContent, DocumentContent, FileContent } from "./content.js";
+export type ContentBlock = TextContent | ImageContent | AudioContent | FileContent | DocumentContent | ThinkingContent | ToolCallDeltaContent | ToolCallContent | ToolResultContent;
 export interface TextContent {
     readonly type: "text";
     readonly text: string;
@@ -26,6 +28,9 @@ export interface ImageContent {
     readonly mimeType?: string;
     readonly data?: string;
     readonly url?: string;
+    readonly resourceUri?: string;
+    readonly name?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
 }
 export interface ThinkingContent {
     readonly type: "thinking";
@@ -71,11 +76,14 @@ export interface ModelConfig {
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
 export interface ModelCapabilities {
+    /** Known values include `text`, `image`, `audio`, `file`, and `document`. */
     readonly input?: readonly string[];
     readonly output?: readonly string[];
     readonly reasoning?: boolean;
     readonly tools?: boolean;
     readonly streaming?: boolean;
+    /** Native JSON-schema structured output support for this model. */
+    readonly structuredOutput?: boolean | "json_schema";
 }
 export interface ModelLimits {
     readonly contextWindow?: number;
@@ -121,6 +129,11 @@ export interface PromptCacheHints {
     readonly retention?: CacheRetention;
     readonly breakpoints?: readonly PromptCacheBreakpoint[];
 }
+export interface StructuredOutputOptions {
+    readonly name: string;
+    readonly schema: JsonObject;
+    readonly strict?: boolean;
+}
 export interface ProviderRequestOptions {
     readonly sessionId?: string;
     readonly cacheRetention?: CacheRetention;
@@ -135,6 +148,8 @@ export interface ProviderRequestOptions {
     readonly maxRetryDelayMs?: number;
     readonly compat?: JsonObject;
     readonly extra?: JsonObject;
+    /** Provider-neutral JSON-schema structured output request. Requires model `capabilities.structuredOutput`. */
+    readonly structuredOutput?: StructuredOutputOptions;
 }
 export interface ProviderRequest {
     readonly model: ModelConfig;
@@ -304,6 +319,20 @@ export interface AgentSession {
     fork(options?: AgentSessionForkOptions): AgentSession;
     clone(options?: AgentSessionCloneOptions): Promise<AgentSession>;
 }
+export interface ProviderTurnMetadata {
+    readonly providerId: string;
+    readonly model: ModelConfig;
+    readonly requestId?: string;
+    readonly latencyMs?: number;
+    readonly attempt?: number;
+    readonly httpStatus?: number;
+    readonly rateLimitRemaining?: number;
+    readonly rateLimitResetMs?: number;
+}
+export interface ToolExecutionMetadata {
+    readonly durationMs: number;
+    readonly status: ToolCallStatus;
+}
 export type AgentEvent = {
     readonly type: "agent_started";
     readonly sessionId: string;
@@ -323,6 +352,20 @@ export type AgentEvent = {
     readonly sessionId: string;
     readonly runId: string;
     readonly turn: number;
+} | {
+    readonly type: "provider_turn_started";
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turn: number;
+    readonly metadata: ProviderTurnMetadata;
+} | {
+    readonly type: "provider_turn_finished";
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly turn: number;
+    readonly metadata: ProviderTurnMetadata;
+    readonly usage?: Usage;
+    readonly error?: ErrorInfo;
 } | {
     readonly type: "message_started";
     readonly sessionId: string;
@@ -356,12 +399,14 @@ export type AgentEvent = {
     readonly sessionId: string;
     readonly runId: string;
     readonly result: ToolResult;
+    readonly metadata: ToolExecutionMetadata;
 } | {
     readonly type: "tool_execution_error";
     readonly sessionId: string;
     readonly runId: string;
     readonly call: ToolCallContent;
     readonly error: ErrorInfo;
+    readonly metadata: ToolExecutionMetadata;
 } | {
     readonly type: "tool_execution_blocked";
     readonly sessionId: string;
@@ -370,6 +415,7 @@ export type AgentEvent = {
     readonly name: string;
     readonly reason: string;
     readonly error: ErrorInfo;
+    readonly metadata: ToolExecutionMetadata;
 } | {
     readonly type: "queue_updated";
     readonly sessionId: string;
@@ -442,6 +488,8 @@ export interface ToolDefinition {
     readonly name: string;
     readonly description?: string;
     readonly parameters?: JsonObject;
+    /** Force any provider turn containing this tool to dispatch sequentially. */
+    readonly exclusive?: boolean;
     execute(args: JsonObject, context: ToolExecutionContext): Promise<ToolResult> | ToolResult;
 }
 export interface ToolRegistry {
@@ -647,6 +695,8 @@ export interface OAuthLoginCallbacks {
         readonly message: string;
         readonly choices: readonly string[];
     }): string | undefined | Promise<string | undefined>;
+    /** Aborts OAuth login flows and device-code polling when signaled. */
+    readonly signal?: AbortSignal;
 }
 export interface OAuthCredentials {
     readonly access?: string;
@@ -832,6 +882,83 @@ export interface PersistenceQuery {
     readonly limit?: number;
     readonly order?: "asc" | "desc";
 }
+/** Generic versioned checkpoint key. Namespaces prevent consumer collisions. */
+export interface CheckpointKey extends OwnershipScope {
+    readonly namespace: string;
+    readonly key: string;
+    readonly signal?: AbortSignal;
+}
+/** Input for an optimistic checkpoint write. Versions must strictly increase. */
+export interface CheckpointSaveInput extends CheckpointKey {
+    readonly version: number;
+    /** Exact current version required before update; use 0 for create-only. */
+    readonly expectedVersion?: number;
+    /** Monotonic lease fence. Lower or absent worker fences cannot replace a fenced record. */
+    readonly fencingToken?: number;
+    readonly value: unknown;
+    readonly category?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Durable generic checkpoint record. */
+export interface CheckpointRecord extends OwnershipScope {
+    readonly namespace: string;
+    readonly key: string;
+    readonly version: number;
+    readonly fencingToken?: number;
+    readonly value: unknown;
+    readonly category?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Bounded checkpoint query. */
+export interface CheckpointQuery extends PersistenceQuery, OwnershipScope {
+    readonly namespace?: string;
+    readonly keyPrefix?: string;
+    readonly category?: string | readonly string[];
+    readonly signal?: AbortSignal;
+}
+/** Generic versioned checkpoint capability for persistence adapters. */
+export interface CheckpointStore {
+    saveCheckpoint(input: CheckpointSaveInput): Promise<CheckpointRecord>;
+    loadCheckpoint(input: CheckpointKey): Promise<CheckpointRecord | null>;
+    listCheckpoints(query?: CheckpointQuery): Promise<PersistencePage<CheckpointRecord>>;
+    deleteCheckpoint(input: CheckpointKey): Promise<boolean>;
+}
+/** Generic lease key. Ownership fields are part of the trust boundary. */
+export interface LeaseKey extends OwnershipScope {
+    readonly namespace: string;
+    readonly key: string;
+    readonly signal?: AbortSignal;
+}
+export interface LeaseAcquireInput extends LeaseKey {
+    readonly ownerId: string;
+    readonly ttlMs: number;
+}
+export interface LeaseClaimInput extends LeaseKey {
+    readonly ownerId: string;
+    readonly token: string;
+    readonly ttlMs?: number;
+}
+export interface LeaseRecord extends OwnershipScope {
+    readonly namespace: string;
+    readonly key: string;
+    readonly ownerId: string;
+    readonly token: string;
+    readonly fencingToken: number;
+    readonly acquiredAt: string;
+    readonly expiresAt: string;
+    readonly updatedAt: string;
+}
+/** Atomic distributed lease capability. Expired rows retain fencing counters. */
+export interface LeaseStore {
+    tryAcquireLease(input: LeaseAcquireInput): Promise<LeaseRecord | null>;
+    renewLease(input: LeaseClaimInput & {
+        readonly ttlMs: number;
+    }): Promise<LeaseRecord | null>;
+    releaseLease(input: LeaseClaimInput): Promise<boolean>;
+    getLease(input: LeaseKey): Promise<LeaseRecord | null>;
+}
 /** Stored session record. Does not include provider objects or credentials. */
 export interface SessionRecord extends OwnershipScope {
     readonly id: string;
@@ -1058,11 +1185,15 @@ export interface MigrationQuery extends PersistenceQuery {
  * Production database-neutral persistence store contract.
  * Hosts implement this interface to provide durable, paginated storage
  * for sessions, entries, runs, events, tool calls, usage, agent definitions,
- * and migrations. No SQL client, ORM, host file storage, or network dependency is
+ * and migrations, with optional generic checkpoint and atomic lease capabilities. No SQL client, ORM, host file storage, or network dependency is
  * required by the contract.
  */
 export interface ProductionPersistenceStore {
     readonly name?: string;
+    /** Optional generic write capability for resumable consumers such as workflows. */
+    readonly checkpoints?: CheckpointStore;
+    /** Optional atomic distributed lease capability for coordinators and workers. */
+    readonly leases?: LeaseStore;
     querySessions(query: SessionQuery): Promise<PersistencePage<SessionRecord>>;
     queryBranches(query: BranchQuery): Promise<PersistencePage<BranchRecord>>;
     queryEntries(query: SessionEntryQuery): Promise<PersistencePage<SessionEntry>>;
@@ -1201,9 +1332,12 @@ export interface LoopContext {
     readonly input: AgentInput;
     readonly inputMessages: readonly Message[];
     readonly maxToolRounds: number;
+    /** Maximum independent tool calls dispatched concurrently per provider turn. Default `1`. */
+    readonly toolConcurrency: number;
     assemble(nextInput: AgentInput, toolResults?: readonly ToolResult[], turn?: number): Promise<ProviderRequest>;
     generate(request: ProviderRequest): Promise<ProviderTurnResult>;
     dispatchToolCall(call: ToolCallContent): Promise<ToolResult>;
+    isToolCallExclusive?(call: ToolCallContent): boolean;
     appendMessage(message: Message): Promise<void>;
     emit(event: AgentEvent): void;
 }
@@ -1213,12 +1347,18 @@ export interface AgentLoopStrategy {
 }
 export type AgentLoopOptions = {
     readonly strategy: "single-shot";
+    /** Independent tool calls per turn run concurrently up to this limit. Default `1` (sequential). */
+    readonly toolConcurrency?: number;
 } | {
     readonly strategy: "generate-validate-revise";
     readonly validator: ArtifactValidator<unknown>;
     readonly parser?: ArtifactParser<unknown>;
     readonly repairer?: ArtifactRepairer<unknown>;
     readonly maxRevisions?: number;
+    /** Native provider JSON-schema output. Ignored when `structuredOutputMode` is `artifact-loop`. */
+    readonly structuredOutput?: StructuredOutputOptions;
+    /** `native` maps schema to capable providers; `artifact-loop` keeps repair turns only. */
+    readonly structuredOutputMode?: "native" | "artifact-loop";
 };
 export interface ArtifactValidation {
     readonly ok: boolean;

package/dist/event-multiplexer.d.ts

@@ -0,0 +1,23 @@
+export type EventOverflowPolicy = "close" | "drop_oldest" | "drop_newest";
+export interface EventOverflowInfo {
+    readonly droppedEvents: number;
+    readonly maxQueuedEvents: number;
+    readonly policy: EventOverflowPolicy;
+}
+export interface EventMultiplexerOptions<T> {
+    readonly maxQueuedEvents?: number;
+    readonly overflow?: EventOverflowPolicy;
+    readonly overflowEvent?: (info: EventOverflowInfo) => T;
+    readonly compare?: (a: T, b: T) => number;
+    readonly signal?: AbortSignal;
+}
+export interface EventMultiplexer<T> {
+    publish(event: T): void;
+    observe<S>(source: AsyncIterable<S>, map: (event: S) => T): () => void;
+    subscribe(): AsyncIterable<T>;
+    close(): void;
+    readonly droppedEvents: number;
+    readonly closed: boolean;
+}
+/** Bounded single-consumer fan-in for arbitrary async event sources. */
+export declare function createEventMultiplexer<T>(options?: EventMultiplexerOptions<T>): EventMultiplexer<T>;

package/dist/event-multiplexer.js

@@ -0,0 +1,136 @@
+/** Bounded single-consumer fan-in for arbitrary async event sources. */
+export function createEventMultiplexer(options = {}) {
+    const maxQueuedEvents = Math.max(1, options.maxQueuedEvents ?? 1024);
+    const overflow = options.overflow ?? "close";
+    const queue = [];
+    const stops = new Set();
+    let waiter;
+    let isClosed = false;
+    let droppedEvents = 0;
+    let overflowNotified = false;
+    const abort = () => close();
+    if (options.signal?.aborted)
+        isClosed = true;
+    else
+        options.signal?.addEventListener("abort", abort, { once: true });
+    function publish(event) {
+        if (isClosed)
+            return;
+        if (waiter) {
+            const resolve = waiter;
+            waiter = undefined;
+            resolve({ value: event, done: false });
+            return;
+        }
+        if (queue.length < maxQueuedEvents) {
+            queue.push(event);
+            return;
+        }
+        droppedEvents += 1;
+        const notice = !overflowNotified && options.overflowEvent
+            ? options.overflowEvent({ droppedEvents, maxQueuedEvents, policy: overflow })
+            : undefined;
+        overflowNotified = true;
+        if (overflow === "close") {
+            queue.length = 0;
+            if (notice !== undefined)
+                queue.push(notice);
+            options.signal?.removeEventListener("abort", abort);
+            finishSources();
+            isClosed = true;
+            return;
+        }
+        if (overflow === "drop_newest") {
+            if (notice !== undefined)
+                queue[queue.length - 1] = notice;
+            return;
+        }
+        queue.shift();
+        if (notice !== undefined) {
+            queue.push(notice);
+            if (queue.length >= maxQueuedEvents)
+                queue.shift();
+        }
+        queue.push(event);
+    }
+    function observe(source, map) {
+        if (isClosed)
+            return () => undefined;
+        const iterator = source[Symbol.asyncIterator]();
+        let stopped = false;
+        const stop = () => {
+            if (stopped)
+                return;
+            stopped = true;
+            stops.delete(stop);
+            void iterator.return?.();
+        };
+        stops.add(stop);
+        void (async () => {
+            try {
+                while (!stopped && !isClosed) {
+                    const next = await iterator.next();
+                    if (next.done)
+                        break;
+                    publish(map(next.value));
+                }
+            }
+            catch {
+                // Source failure ends that source; owners surface source errors separately.
+            }
+            finally {
+                stop();
+            }
+        })();
+        return stop;
+    }
+    function finishSources() {
+        for (const stop of [...stops])
+            stop();
+        stops.clear();
+    }
+    function close() {
+        if (isClosed)
+            return;
+        isClosed = true;
+        options.signal?.removeEventListener("abort", abort);
+        finishSources();
+        queue.length = 0;
+        if (waiter) {
+            const resolve = waiter;
+            waiter = undefined;
+            resolve({ value: undefined, done: true });
+        }
+    }
+    async function* subscribe() {
+        while (true) {
+            if (queue.length > 0) {
+                if (options.compare)
+                    queue.sort(options.compare);
+                yield queue.shift();
+                continue;
+            }
+            if (isClosed)
+                return;
+            const next = await new Promise((resolve) => {
+                waiter = resolve;
+            });
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    return {
+        publish,
+        observe,
+        subscribe,
+        close,
+        get droppedEvents() {
+            return droppedEvents;
+        },
+        get closed() {
+            return isClosed;
+        },
+    };
+}
+//# sourceMappingURL=event-multiplexer.js.map

package/dist/execution-policy.d.ts

@@ -0,0 +1,28 @@
+export type ExecutionRisk = "low" | "medium" | "high";
+export interface ExecutionAction {
+    readonly kind: "shell" | "read" | "write" | "edit" | string;
+    readonly operation: string;
+    readonly paths?: readonly string[];
+    readonly command?: string;
+    readonly risk?: ExecutionRisk;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface ExecutionDecision {
+    readonly allowed: boolean;
+    readonly reason?: string;
+    readonly modified?: Partial<ExecutionAction>;
+    /** When true, tool definitions should expose `exclusive: true` for pre-dispatch serialization. */
+    readonly exclusive?: boolean;
+}
+export interface ExecutionPolicy {
+    check(action: ExecutionAction): ExecutionDecision | Promise<ExecutionDecision>;
+}
+export declare class ExecutionDeniedError extends Error {
+    readonly action: ExecutionAction;
+    readonly decision: ExecutionDecision;
+    readonly code = "ERR_PRISM_EXECUTION_DENIED";
+    constructor(action: ExecutionAction, decision: ExecutionDecision);
+}
+export declare function checkExecution(policy: ExecutionPolicy | undefined, action: ExecutionAction): Promise<ExecutionDecision>;
+export declare function applyExecutionDecision(action: ExecutionAction, decision: ExecutionDecision): ExecutionAction;
+export declare function assertExecutionAllowed(policy: ExecutionPolicy | undefined, action: ExecutionAction): Promise<ExecutionAction>;

package/dist/execution-policy.js

@@ -0,0 +1,24 @@
+export class ExecutionDeniedError extends Error {
+    action;
+    decision;
+    code = "ERR_PRISM_EXECUTION_DENIED";
+    constructor(action, decision) {
+        super(decision.reason ?? `Execution denied for ${action.kind}:${action.operation}`);
+        this.action = action;
+        this.decision = decision;
+        this.name = "ExecutionDeniedError";
+    }
+}
+export async function checkExecution(policy, action) {
+    return policy ? await policy.check(action) : { allowed: true };
+}
+export function applyExecutionDecision(action, decision) {
+    return decision.modified ? { ...action, ...decision.modified } : action;
+}
+export async function assertExecutionAllowed(policy, action) {
+    const decision = await checkExecution(policy, action);
+    if (!decision.allowed)
+        throw new ExecutionDeniedError(action, decision);
+    return applyExecutionDecision(action, decision);
+}
+//# sourceMappingURL=execution-policy.js.map

package/dist/index.d.ts

@@ -1,6 +1,11 @@
 export type * from "./contracts.js";
 export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.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 +24,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 +33,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, sniffMediaMimeType, UnsupportedModalityError, } from "./content.js";
+export type { AudioContent, DocumentContent, FileContent, MediaContentBlock, MediaContentBounds, MediaMimePolicy, 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 +54,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.2";
+export declare const version = "0.0.4";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,5 +1,8 @@
 export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict } from "./contracts.js";
 export { createAgent, createAgentSession } from "./agents.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 +14,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, 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 +30,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.2";
+export const version = "0.0.4";
 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;