@arnilo/prism 0.0.11 → 0.0.13

package/dist/identity.js

@@ -0,0 +1,257 @@
+export const DEFAULT_IDENTITY_LIMITS = {
+    maxScopes: 64,
+    maxScopeBytes: 128,
+    maxMetadataBytes: 4 * 1024,
+    maxCredentialRefBytes: 256,
+    maxPrincipalIdBytes: 256,
+};
+export const HARD_IDENTITY_LIMITS = {
+    maxScopes: 256,
+    maxScopeBytes: 512,
+    maxMetadataBytes: 16 * 1024,
+    maxCredentialRefBytes: 2 * 1024,
+    maxPrincipalIdBytes: 2 * 1024,
+};
+export class IdentityError extends Error {
+    reason;
+    code = "ERR_PRISM_IDENTITY";
+    constructor(message, reason) {
+        super(message);
+        this.reason = reason;
+        this.name = "IdentityError";
+    }
+}
+export function resolveIdentityLimits(input = {}) {
+    return {
+        maxScopes: bound("maxScopes", input.maxScopes, DEFAULT_IDENTITY_LIMITS.maxScopes, HARD_IDENTITY_LIMITS.maxScopes),
+        maxScopeBytes: bound("maxScopeBytes", input.maxScopeBytes, DEFAULT_IDENTITY_LIMITS.maxScopeBytes, HARD_IDENTITY_LIMITS.maxScopeBytes),
+        maxMetadataBytes: bound("maxMetadataBytes", input.maxMetadataBytes, DEFAULT_IDENTITY_LIMITS.maxMetadataBytes, HARD_IDENTITY_LIMITS.maxMetadataBytes),
+        maxCredentialRefBytes: bound("maxCredentialRefBytes", input.maxCredentialRefBytes, DEFAULT_IDENTITY_LIMITS.maxCredentialRefBytes, HARD_IDENTITY_LIMITS.maxCredentialRefBytes),
+        maxPrincipalIdBytes: bound("maxPrincipalIdBytes", input.maxPrincipalIdBytes, DEFAULT_IDENTITY_LIMITS.maxPrincipalIdBytes, HARD_IDENTITY_LIMITS.maxPrincipalIdBytes),
+    };
+}
+/** Project verified identity onto ownership scope fields used by persistence/server. */
+export function ownershipFromIdentity(identity) {
+    return {
+        tenantId: identity.tenantId,
+        ...(identity.accountId !== undefined ? { accountId: identity.accountId } : {}),
+        ...(identity.userId !== undefined ? { userId: identity.userId } : {}),
+    };
+}
+/**
+ * Fail closed on shape/limits/expiry/revocation/tenant mismatch.
+ * Sync and network-free — host {@link IdentityVerifier} owns remote checks.
+ */
+export function assertIdentityActive(identity, options = {}) {
+    const limits = resolveIdentityLimits(options.limits);
+    assertIdentityShape(identity, limits);
+    if (identity.verified !== true)
+        throw new IdentityError("Identity is not host-verified", "unverified");
+    if (options.expectedTenantId !== undefined && identity.tenantId !== options.expectedTenantId) {
+        throw new IdentityError("Identity tenant mismatch", "wrong_tenant");
+    }
+    const now = options.now ?? Date.now();
+    if (identity.revokedAt !== undefined) {
+        const revokedAt = Date.parse(identity.revokedAt);
+        if (!Number.isFinite(revokedAt))
+            throw new IdentityError("Identity revokedAt is invalid", "invalid_revoked_at");
+        if (revokedAt <= now)
+            throw new IdentityError("Identity has been revoked", "revoked");
+    }
+    if (identity.expiresAt !== undefined) {
+        const expiresAt = Date.parse(identity.expiresAt);
+        if (!Number.isFinite(expiresAt))
+            throw new IdentityError("Identity expiresAt is invalid", "invalid_expires_at");
+        if (expiresAt <= now)
+            throw new IdentityError("Identity has expired", "expired");
+    }
+    const issuedAt = Date.parse(identity.issuedAt);
+    if (!Number.isFinite(issuedAt))
+        throw new IdentityError("Identity issuedAt is invalid", "invalid_issued_at");
+    if (issuedAt > now + 60_000)
+        throw new IdentityError("Identity issuedAt is in the future", "invalid_issued_at");
+}
+/** Delegation may only narrow scopes; tenant and ownership ids stay immutable. */
+export function narrowIdentity(parent, options) {
+    assertIdentityActive(parent, { limits: options.limits });
+    const limits = resolveIdentityLimits(options.limits);
+    if (options.scopes.length === 0)
+        throw new IdentityError("Delegated scopes must be non-empty", "empty_scopes");
+    const parentScopes = new Set(parent.scopes);
+    for (const scope of options.scopes) {
+        if (!parentScopes.has(scope))
+            throw new IdentityError(`Delegation widens scope: ${scope}`, "scope_widen");
+    }
+    if (options.expiresAt !== undefined) {
+        const childExp = Date.parse(options.expiresAt);
+        if (!Number.isFinite(childExp))
+            throw new IdentityError("Delegated expiresAt is invalid", "invalid_expires_at");
+        if (parent.expiresAt !== undefined) {
+            const parentExp = Date.parse(parent.expiresAt);
+            if (Number.isFinite(parentExp) && childExp > parentExp) {
+                throw new IdentityError("Delegation cannot extend expiry", "expiry_widen");
+            }
+        }
+    }
+    const child = {
+        tenantId: parent.tenantId,
+        ...(parent.accountId !== undefined ? { accountId: parent.accountId } : {}),
+        ...(parent.userId !== undefined ? { userId: parent.userId } : {}),
+        principal: options.principal ?? parent.principal,
+        ...(parent.sponsor !== undefined ? { sponsor: parent.sponsor } : {}),
+        ...(parent.owner !== undefined ? { owner: parent.owner } : {}),
+        delegatedFrom: parent.principal,
+        scopes: Object.freeze([...options.scopes]),
+        credentialRefs: Object.freeze([...(options.credentialRefs ?? parent.credentialRefs ?? [])]),
+        issuedAt: parent.issuedAt,
+        ...(options.expiresAt !== undefined ? { expiresAt: options.expiresAt } : parent.expiresAt !== undefined ? { expiresAt: parent.expiresAt } : {}),
+        ...(parent.revokedAt !== undefined ? { revokedAt: parent.revokedAt } : {}),
+        ...(options.metadata !== undefined ? { metadata: options.metadata } : parent.metadata !== undefined ? { metadata: parent.metadata } : {}),
+        verified: true,
+    };
+    assertIdentityActive(child, { limits: options.limits });
+    assertPrincipalBounds(child.principal, limits);
+    return child;
+}
+/** Refuse ownership that widens or conflicts with a verified identity. */
+export function assertIdentityMatchesOwnership(identity, ownership) {
+    assertIdentityActive(identity);
+    if (!ownership)
+        return;
+    if (ownership.tenantId !== undefined && ownership.tenantId !== identity.tenantId) {
+        throw new IdentityError("Ownership tenant conflicts with identity", "ownership_tenant");
+    }
+    if (ownership.accountId !== undefined) {
+        if (identity.accountId === undefined || ownership.accountId !== identity.accountId) {
+            throw new IdentityError("Ownership account conflicts with identity", "ownership_account");
+        }
+    }
+    if (ownership.userId !== undefined) {
+        if (identity.userId === undefined || ownership.userId !== identity.userId) {
+            throw new IdentityError("Ownership user conflicts with identity", "ownership_user");
+        }
+    }
+}
+/**
+ * Propagation check: child must share tenant, not widen scopes, and remain active.
+ * Used by supervisor/A2A/MCP/server when forwarding identity across a boundary.
+ */
+export function assertIdentityPropagation(parent, child, options = {}) {
+    assertIdentityActive(parent, options);
+    assertIdentityActive(child, options);
+    if (child.tenantId !== parent.tenantId)
+        throw new IdentityError("Propagated identity changed tenant", "tenant_widen");
+    if (parent.accountId !== undefined && child.accountId !== parent.accountId) {
+        throw new IdentityError("Propagated identity changed account", "account_widen");
+    }
+    if (parent.userId !== undefined && child.userId !== parent.userId) {
+        throw new IdentityError("Propagated identity changed user", "user_widen");
+    }
+    const parentScopes = new Set(parent.scopes);
+    for (const scope of child.scopes) {
+        if (!parentScopes.has(scope))
+            throw new IdentityError(`Propagated identity widens scope: ${scope}`, "scope_widen");
+    }
+}
+/** Redacted identity refs safe for telemetry/ledger metadata (no secrets, no raw JWT). */
+export function identityTelemetryAttributes(identity) {
+    assertIdentityActive(identity);
+    return {
+        "prism.identity.tenant_id": identity.tenantId,
+        "prism.identity.principal_kind": String(identity.principal.kind),
+        "prism.identity.principal_id": identity.principal.id,
+        "prism.identity.scope_count": String(identity.scopes.length),
+        ...(identity.accountId !== undefined ? { "prism.identity.account_id": identity.accountId } : {}),
+        ...(identity.userId !== undefined ? { "prism.identity.user_id": identity.userId } : {}),
+        ...(identity.sponsor !== undefined ? { "prism.identity.sponsor_id": identity.sponsor.id } : {}),
+        ...(identity.credentialRefs?.length ? { "prism.identity.credential_ref_count": String(identity.credentialRefs.length) } : {}),
+    };
+}
+/** Resolve run identity: explicit option wins; otherwise agent default. Assert when present. */
+export function resolveRunIdentity(runIdentity, agentIdentity, ownership, options = {}) {
+    const identity = runIdentity ?? agentIdentity;
+    if (!identity)
+        return undefined;
+    assertIdentityActive(identity, options);
+    assertIdentityMatchesOwnership(identity, ownership ?? ownershipFromIdentity(identity));
+    return identity;
+}
+function assertIdentityShape(identity, limits) {
+    if (typeof identity.tenantId !== "string" || identity.tenantId.length === 0) {
+        throw new IdentityError("Identity tenantId is required", "missing_tenant");
+    }
+    if (byteLength(identity.tenantId) > limits.maxPrincipalIdBytes) {
+        throw new IdentityError("Identity tenantId exceeds byte limit", "tenant_too_large");
+    }
+    assertPrincipalBounds(identity.principal, limits);
+    if (identity.sponsor)
+        assertPrincipalBounds(identity.sponsor, limits);
+    if (identity.owner)
+        assertPrincipalBounds(identity.owner, limits);
+    if (identity.delegatedFrom)
+        assertPrincipalBounds(identity.delegatedFrom, limits);
+    if (!Array.isArray(identity.scopes) || identity.scopes.length === 0) {
+        throw new IdentityError("Identity scopes must be a non-empty array", "empty_scopes");
+    }
+    if (identity.scopes.length > limits.maxScopes) {
+        throw new IdentityError(`Identity exceeds maxScopes (${limits.maxScopes})`, "too_many_scopes");
+    }
+    for (const scope of identity.scopes) {
+        if (typeof scope !== "string" || scope.length === 0)
+            throw new IdentityError("Identity scope is invalid", "invalid_scope");
+        if (byteLength(scope) > limits.maxScopeBytes)
+            throw new IdentityError("Identity scope exceeds byte limit", "scope_too_large");
+    }
+    if (identity.credentialRefs) {
+        for (const ref of identity.credentialRefs) {
+            if (typeof ref !== "string" || ref.length === 0)
+                throw new IdentityError("Credential ref is invalid", "invalid_credential_ref");
+            if (byteLength(ref) > limits.maxCredentialRefBytes) {
+                throw new IdentityError("Credential ref exceeds byte limit", "credential_ref_too_large");
+            }
+        }
+    }
+    if (identity.metadata !== undefined) {
+        let encoded;
+        try {
+            encoded = JSON.stringify(identity.metadata);
+        }
+        catch {
+            throw new IdentityError("Identity metadata is not JSON-serializable", "invalid_metadata");
+        }
+        if (byteLength(encoded) > limits.maxMetadataBytes) {
+            throw new IdentityError("Identity metadata exceeds byte limit", "metadata_too_large");
+        }
+    }
+    if (identity.accountId !== undefined && byteLength(identity.accountId) > limits.maxPrincipalIdBytes) {
+        throw new IdentityError("Identity accountId exceeds byte limit", "account_too_large");
+    }
+    if (identity.userId !== undefined && byteLength(identity.userId) > limits.maxPrincipalIdBytes) {
+        throw new IdentityError("Identity userId exceeds byte limit", "user_too_large");
+    }
+}
+function assertPrincipalBounds(principal, limits) {
+    if (typeof principal.id !== "string" || principal.id.length === 0) {
+        throw new IdentityError("Principal id is required", "missing_principal");
+    }
+    if (byteLength(principal.id) > limits.maxPrincipalIdBytes) {
+        throw new IdentityError("Principal id exceeds byte limit", "principal_too_large");
+    }
+    if (typeof principal.kind !== "string" || principal.kind.length === 0 || byteLength(principal.kind) > 64) {
+        throw new IdentityError("Principal kind is invalid", "invalid_principal_kind");
+    }
+    if (principal.displayName !== undefined && byteLength(principal.displayName) > limits.maxPrincipalIdBytes) {
+        throw new IdentityError("Principal displayName exceeds byte limit", "display_name_too_large");
+    }
+}
+function bound(name, value, fallback, hard) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > hard) {
+        throw new RangeError(`${name} must be a positive safe integer no greater than ${hard}`);
+    }
+    return resolved;
+}
+function byteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+//# sourceMappingURL=identity.js.map

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type * from "./contracts.js";
 export type { RunLimitCounters, RunLimitName, SecureAgentOptions } from "./contracts.js";
 export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict, AgentRunError, AgentRunStateError, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SESSION_SEARCH_UNSUPPORTED_CODE, SessionSearchUnsupportedError, isSessionSearchUnsupported, DEFAULT_SESSION_SEARCH_LIMIT, HARD_MAX_SESSION_SEARCH_LIMIT, DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES, HARD_MAX_SESSION_SEARCH_QUERY_BYTES, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES, DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES, HARD_MAX_SESSION_SEARCH_CURSOR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, HARD_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES, HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES, resolveSessionSearchQuery, DEFAULT_MAX_PENDING_STEERS, HARD_MAX_PENDING_STEERS, DEFAULT_MAX_PENDING_STEER_BYTES, HARD_MAX_PENDING_STEER_BYTES } from "./contracts.js";
-export { createAgent, createAgentSession, resumeAgentRun } from "./agents.js";
+export { createAgent, createAgentSession, resumeAgentRun, resumeAgentRunStream } from "./agents.js";
 export { createBatchedRunLedger, isFlushableRunLedger, DEFAULT_LEDGER_BATCH_ENTRIES, HARD_LEDGER_BATCH_ENTRIES, DEFAULT_LEDGER_BATCH_BYTES, HARD_LEDGER_BATCH_BYTES, DEFAULT_LEDGER_BATCH_DELAY_MS, HARD_LEDGER_BATCH_DELAY_MS, } from "./run-ledger.js";
 export type { BatchedRunLedgerOptions } from "./run-ledger.js";
 export { createSecureAgent } from "./secure-agent.js";
@@ -11,9 +11,11 @@ export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpoi
 export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, agentFingerprint, loadAgentRunState } from "./agent-run-state.js";
 export type { StoredAgentRunState } from "./agent-run-state.js";
 export { createAgentRunLifecycle } from "./agent-run-lifecycle.js";
-export type { AgentRunLifecycle, AgentRunLifecycleAgent, AgentRunLifecycleOptions, AgentRunLifecycleRequest } from "./agent-run-lifecycle.js";
+export type { AgentRunLifecycle, AgentRunLifecycleAgent, AgentRunLifecycleOptions, AgentRunLifecycleRequest, AgentRunLifecycleStreamRequest } from "./agent-run-lifecycle.js";
 export type { MemoryCheckpointStoreOptions } from "./checkpoints.js";
 export { LEASE_CONFLICT_CODE, LeaseConflictError, createMemoryLeaseStore } from "./leases.js";
+export { createMemoryPersistenceLifecycle, isResourceHeld, PersistenceLifecycleError, DEFAULT_LIFECYCLE_PAGE_SIZE, HARD_LIFECYCLE_PAGE_SIZE, DEFAULT_MAX_HOLD_REASON_BYTES, HARD_MAX_HOLD_REASON_BYTES, } from "./persistence-lifecycle.js";
+export type { PersistenceResourceKind, LegalHoldRecord, PutLegalHoldInput, ReleaseLegalHoldInput, LegalHoldQuery, ApplyRetentionInput, ApplyRetentionResult, LegalHoldExportItem, ExportUnderHoldInput, TenantQuota, SetTenantQuotaInput, ConsumeTenantQuotaInput, PersistenceLifecycleStore, } from "./persistence-lifecycle.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";
@@ -30,7 +32,7 @@ export { createContributionRegistries, createContributionRegistry, registerDisco
 export type { ContributionRegistries, ContributionRegistriesOptions, ContributionRegistry, ContributionRegistryOptions } from "./contributions.js";
 export { createChainedCredentialResolver, createEnvCredentialResolver, createExplicitCredentialResolver, createMemoryCredentialStore, refreshOAuthCredential, resolveCredentialValue } from "./credentials.js";
 export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
-export type { ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions } from "./extensions.js";
+export type { ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions, ExtensionLoadPolicy } from "./extensions.js";
 export type { CredentialRecord, CredentialValueSource, MemoryCredentialStore } from "./credentials.js";
 export { createModelRegistry } from "./models.js";
 export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
@@ -70,6 +72,8 @@ 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 { assertIdentityActive, assertIdentityMatchesOwnership, assertIdentityPropagation, DEFAULT_IDENTITY_LIMITS, HARD_IDENTITY_LIMITS, IdentityError, identityTelemetryAttributes, narrowIdentity, ownershipFromIdentity, resolveIdentityLimits, resolveRunIdentity, } from "./identity.js";
+export type { AgentIdentity, AssertIdentityActiveOptions, IdentityLimits, IdentityVerifier, NarrowIdentityOptions, Principal, ResolvedIdentityLimits, } from "./identity.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";
@@ -85,5 +89,5 @@ export type { DispatchToolCallOptions, ToolArgumentValidationError, ToolArgument
 export type { DuplicateRegistrationOptions, DuplicateRegistrationPolicy } from "./registry-options.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop } from "./agent-loops.js";
 export declare const name = "prism";
-export declare const version = "0.0.11";
+export declare const version = "0.0.13";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, isSessionAppendConflict, AgentRunError, AgentRunStateError, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SESSION_SEARCH_UNSUPPORTED_CODE, SessionSearchUnsupportedError, isSessionSearchUnsupported, DEFAULT_SESSION_SEARCH_LIMIT, HARD_MAX_SESSION_SEARCH_LIMIT, DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES, HARD_MAX_SESSION_SEARCH_QUERY_BYTES, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES, DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES, HARD_MAX_SESSION_SEARCH_CURSOR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, HARD_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES, HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES, resolveSessionSearchQuery, DEFAULT_MAX_PENDING_STEERS, HARD_MAX_PENDING_STEERS, DEFAULT_MAX_PENDING_STEER_BYTES, HARD_MAX_PENDING_STEER_BYTES } from "./contracts.js";
-export { createAgent, createAgentSession, resumeAgentRun } from "./agents.js";
+export { createAgent, createAgentSession, resumeAgentRun, resumeAgentRunStream } from "./agents.js";
 export { createBatchedRunLedger, isFlushableRunLedger, DEFAULT_LEDGER_BATCH_ENTRIES, HARD_LEDGER_BATCH_ENTRIES, DEFAULT_LEDGER_BATCH_BYTES, HARD_LEDGER_BATCH_BYTES, DEFAULT_LEDGER_BATCH_DELAY_MS, HARD_LEDGER_BATCH_DELAY_MS, } from "./run-ledger.js";
 export { createSecureAgent } from "./secure-agent.js";
 export { createMemoryRunFeedbackStore, prepareRunFeedback, requireRunFeedbackOwnership, runFeedbackPageLimit, RunFeedbackError, } from "./feedback.js";
@@ -7,6 +7,7 @@ export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpoi
 export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, agentFingerprint, loadAgentRunState } from "./agent-run-state.js";
 export { createAgentRunLifecycle } from "./agent-run-lifecycle.js";
 export { LEASE_CONFLICT_CODE, LeaseConflictError, createMemoryLeaseStore } from "./leases.js";
+export { createMemoryPersistenceLifecycle, isResourceHeld, PersistenceLifecycleError, DEFAULT_LIFECYCLE_PAGE_SIZE, HARD_LIFECYCLE_PAGE_SIZE, DEFAULT_MAX_HOLD_REASON_BYTES, HARD_MAX_HOLD_REASON_BYTES, } from "./persistence-lifecycle.js";
 export { createEventMultiplexer } from "./event-multiplexer.js";
 export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, sanitizeCacheKey } from "./cache-helpers.js";
 export { resolveAgentDefinition } from "./agent-definitions.js";
@@ -38,6 +39,7 @@ 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 { assertIdentityActive, assertIdentityMatchesOwnership, assertIdentityPropagation, DEFAULT_IDENTITY_LIMITS, HARD_IDENTITY_LIMITS, IdentityError, identityTelemetryAttributes, narrowIdentity, ownershipFromIdentity, resolveIdentityLimits, resolveRunIdentity, } from "./identity.js";
 export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
 export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
 export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
@@ -46,6 +48,6 @@ export { assertGuardrailsAllowed, GuardrailError, MAX_GUARDRAIL_CONCURRENCY, run
 export { createRunLimitTracker, DEFAULT_RUN_LIMITS, HARD_MAX_RUN_COST, HARD_RUN_LIMITS, RunLimitError, RunLimitTracker, resolveRunLimits } from "./run-limits.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop } from "./agent-loops.js";
 export const name = "prism";
-export const version = "0.0.11";
+export const version = "0.0.13";
 export const description = "Agent harness for AI providers, agents, sessions, and tools.";
 //# sourceMappingURL=index.js.map

package/dist/persistence-lifecycle.d.ts

@@ -0,0 +1,103 @@
+import type { OwnershipScope, PersistencePage, PersistenceQuery, RetentionPolicy } from "./contracts.js";
+/** Resource classes covered by holds, quotas, and retention sweeps. */
+export type PersistenceResourceKind = "session" | "entry" | "run" | "event" | "tool_call" | "usage" | "checkpoint" | "feedback" | "audit" | "work_artifact" | "connector_operation";
+export declare const DEFAULT_LIFECYCLE_PAGE_SIZE = 100;
+export declare const HARD_LIFECYCLE_PAGE_SIZE = 500;
+export declare const DEFAULT_MAX_HOLD_REASON_BYTES = 1024;
+export declare const HARD_MAX_HOLD_REASON_BYTES: number;
+export declare class PersistenceLifecycleError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+export interface LegalHoldRecord extends OwnershipScope {
+    readonly id: string;
+    readonly resourceKind: PersistenceResourceKind;
+    readonly resourceId: string;
+    readonly reason: string;
+    readonly createdAt: string;
+    readonly createdBy?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface PutLegalHoldInput extends OwnershipScope {
+    readonly resourceKind: PersistenceResourceKind;
+    readonly resourceId: string;
+    readonly reason: string;
+    readonly id?: string;
+    readonly createdBy?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly signal?: AbortSignal;
+}
+export interface ReleaseLegalHoldInput extends OwnershipScope {
+    readonly id: string;
+    readonly signal?: AbortSignal;
+}
+export interface LegalHoldQuery extends PersistenceQuery, OwnershipScope {
+    readonly resourceKind?: PersistenceResourceKind;
+    readonly resourceId?: string;
+    readonly holdId?: string;
+    readonly signal?: AbortSignal;
+}
+export interface ApplyRetentionInput extends OwnershipScope {
+    readonly policy: RetentionPolicy;
+    /** When omitted, adapters discover expired/over-limit session ids for this ownership page. */
+    readonly candidates?: readonly string[];
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+export interface ApplyRetentionResult {
+    readonly deleted: readonly string[];
+    readonly skippedHeld: readonly string[];
+    readonly nextCursor?: string;
+}
+export interface LegalHoldExportItem {
+    readonly holdId: string;
+    readonly resourceKind: PersistenceResourceKind;
+    readonly resourceId: string;
+    readonly reason: string;
+    readonly createdAt: string;
+    readonly redacted: true;
+}
+export interface ExportUnderHoldInput extends OwnershipScope {
+    readonly holdId?: string;
+    readonly resourceKind?: PersistenceResourceKind;
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+}
+export interface TenantQuota extends OwnershipScope {
+    readonly resourceKind: PersistenceResourceKind;
+    readonly limit: number;
+    readonly used: number;
+    readonly updatedAt: string;
+}
+export interface SetTenantQuotaInput extends OwnershipScope {
+    readonly resourceKind: PersistenceResourceKind;
+    readonly limit: number;
+    readonly signal?: AbortSignal;
+}
+export interface ConsumeTenantQuotaInput extends OwnershipScope {
+    readonly resourceKind: PersistenceResourceKind;
+    /** Units to consume. Default 1. */
+    readonly delta?: number;
+    readonly signal?: AbortSignal;
+}
+/** Optional persistence lifecycle capability (retention / hold / export / quota). */
+export interface PersistenceLifecycleStore {
+    putLegalHold(input: PutLegalHoldInput): Promise<LegalHoldRecord>;
+    releaseLegalHold(input: ReleaseLegalHoldInput): Promise<boolean>;
+    listLegalHolds(query: LegalHoldQuery): Promise<PersistencePage<LegalHoldRecord>>;
+    /** Deletes candidates not under legal hold. Hold always wins over retention. */
+    applyRetention(input: ApplyRetentionInput): Promise<ApplyRetentionResult>;
+    exportUnderHold(input: ExportUnderHoldInput): Promise<PersistencePage<LegalHoldExportItem>>;
+    setTenantQuota(input: SetTenantQuotaInput): Promise<TenantQuota>;
+    getTenantQuota(input: OwnershipScope & {
+        readonly resourceKind: PersistenceResourceKind;
+        readonly signal?: AbortSignal;
+    }): Promise<TenantQuota | null>;
+    /** Fails closed when used + delta would exceed limit. */
+    consumeTenantQuota(input: ConsumeTenantQuotaInput): Promise<TenantQuota>;
+}
+export declare function createMemoryPersistenceLifecycle(): PersistenceLifecycleStore;
+/** True when a session/resource id is under an active legal hold in the page of holds. */
+export declare function isResourceHeld(holds: readonly Pick<LegalHoldRecord, "resourceKind" | "resourceId">[], resourceKind: PersistenceResourceKind, resourceId: string): boolean;

package/dist/persistence-lifecycle.js

@@ -0,0 +1,204 @@
+export const DEFAULT_LIFECYCLE_PAGE_SIZE = 100;
+export const HARD_LIFECYCLE_PAGE_SIZE = 500;
+export const DEFAULT_MAX_HOLD_REASON_BYTES = 1024;
+export const HARD_MAX_HOLD_REASON_BYTES = 8 * 1024;
+export class PersistenceLifecycleError extends Error {
+    code;
+    constructor(message, code = "ERR_PRISM_PERSISTENCE_LIFECYCLE") {
+        super(message);
+        this.code = code;
+        this.name = "PersistenceLifecycleError";
+    }
+}
+export function createMemoryPersistenceLifecycle() {
+    const holds = new Map();
+    const quotas = new Map();
+    const deleted = new Set();
+    return {
+        async putLegalHold(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            const reason = assertReason(input.reason);
+            if (!input.resourceId || !input.resourceKind) {
+                throw new PersistenceLifecycleError("resourceKind and resourceId are required", "ERR_PRISM_LIFECYCLE_HOLD");
+            }
+            const id = input.id ?? crypto.randomUUID();
+            const record = {
+                id,
+                resourceKind: input.resourceKind,
+                resourceId: input.resourceId,
+                reason,
+                createdAt: new Date().toISOString(),
+                ...(input.createdBy === undefined ? {} : { createdBy: input.createdBy }),
+                ...(input.metadata === undefined ? {} : { metadata: input.metadata }),
+                ...ownership(input),
+            };
+            holds.set(id, record);
+            return record;
+        },
+        async releaseLegalHold(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            const current = holds.get(input.id);
+            if (!current)
+                return false;
+            assertSameOwnership(input, current);
+            holds.delete(input.id);
+            return true;
+        },
+        async listLegalHolds(query) {
+            throwIfAborted(query.signal);
+            assertOwnership(query);
+            const limit = pageLimit(query.limit);
+            const items = [...holds.values()]
+                .filter((hold) => sameOwnership(query, hold))
+                .filter((hold) => query.holdId === undefined || hold.id === query.holdId)
+                .filter((hold) => query.resourceKind === undefined || hold.resourceKind === query.resourceKind)
+                .filter((hold) => query.resourceId === undefined || hold.resourceId === query.resourceId)
+                .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+            const start = query.cursor ? items.findIndex((item) => item.id === query.cursor) + 1 : 0;
+            const slice = items.slice(Math.max(0, start), Math.max(0, start) + limit);
+            const next = start + limit < items.length ? slice.at(-1)?.id : undefined;
+            return { items: slice, ...(next === undefined ? {} : { nextCursor: next }) };
+        },
+        async applyRetention(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            const held = new Set([...holds.values()]
+                .filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session")
+                .map((hold) => hold.resourceId));
+            const candidates = input.candidates ?? [];
+            const deletedIds = [];
+            const skippedHeld = [];
+            for (const id of candidates) {
+                if (held.has(id)) {
+                    skippedHeld.push(id);
+                    continue;
+                }
+                deleted.add(id);
+                deletedIds.push(id);
+            }
+            return { deleted: deletedIds, skippedHeld };
+        },
+        async exportUnderHold(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            const page = await this.listLegalHolds({
+                ...ownership(input),
+                holdId: input.holdId,
+                resourceKind: input.resourceKind,
+                cursor: input.cursor,
+                limit: input.limit,
+                signal: input.signal,
+            });
+            return {
+                items: page.items.map((hold) => ({
+                    holdId: hold.id,
+                    resourceKind: hold.resourceKind,
+                    resourceId: hold.resourceId,
+                    reason: hold.reason,
+                    createdAt: hold.createdAt,
+                    redacted: true,
+                })),
+                ...(page.nextCursor === undefined ? {} : { nextCursor: page.nextCursor }),
+            };
+        },
+        async setTenantQuota(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            if (!Number.isSafeInteger(input.limit) || input.limit < 0) {
+                throw new PersistenceLifecycleError("limit must be a non-negative safe integer", "ERR_PRISM_LIFECYCLE_QUOTA");
+            }
+            const key = quotaKey(input, input.resourceKind);
+            const previous = quotas.get(key);
+            const record = {
+                ...ownership(input),
+                resourceKind: input.resourceKind,
+                limit: input.limit,
+                used: previous?.used ?? 0,
+                updatedAt: new Date().toISOString(),
+            };
+            if (record.used > record.limit) {
+                throw new PersistenceLifecycleError("quota already exceeded", "ERR_PRISM_LIFECYCLE_QUOTA");
+            }
+            quotas.set(key, record);
+            return record;
+        },
+        async getTenantQuota(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            return quotas.get(quotaKey(input, input.resourceKind)) ?? null;
+        },
+        async consumeTenantQuota(input) {
+            throwIfAborted(input.signal);
+            assertOwnership(input);
+            const delta = input.delta ?? 1;
+            if (!Number.isSafeInteger(delta) || delta < 1) {
+                throw new PersistenceLifecycleError("delta must be a positive safe integer", "ERR_PRISM_LIFECYCLE_QUOTA");
+            }
+            const key = quotaKey(input, input.resourceKind);
+            const current = quotas.get(key);
+            if (!current) {
+                throw new PersistenceLifecycleError("tenant quota not configured", "ERR_PRISM_LIFECYCLE_QUOTA");
+            }
+            if (current.used + delta > current.limit) {
+                throw new PersistenceLifecycleError(`tenant quota exhausted for ${input.resourceKind}`, "ERR_PRISM_LIFECYCLE_QUOTA_EXHAUSTED");
+            }
+            const next = {
+                ...current,
+                used: current.used + delta,
+                updatedAt: new Date().toISOString(),
+            };
+            quotas.set(key, next);
+            return next;
+        },
+    };
+}
+/** True when a session/resource id is under an active legal hold in the page of holds. */
+export function isResourceHeld(holds, resourceKind, resourceId) {
+    return holds.some((hold) => hold.resourceKind === resourceKind && hold.resourceId === resourceId);
+}
+function ownership(input) {
+    return {
+        ...(input.tenantId === undefined ? {} : { tenantId: input.tenantId }),
+        ...(input.accountId === undefined ? {} : { accountId: input.accountId }),
+        ...(input.userId === undefined ? {} : { userId: input.userId }),
+    };
+}
+function sameOwnership(a, b) {
+    return a.tenantId === b.tenantId && a.accountId === b.accountId && a.userId === b.userId;
+}
+function assertSameOwnership(expected, actual) {
+    if (!sameOwnership(expected, actual)) {
+        throw new PersistenceLifecycleError("ownership mismatch", "ERR_PRISM_LIFECYCLE_OWNERSHIP");
+    }
+}
+function assertOwnership(input) {
+    if (![input.tenantId, input.accountId, input.userId].some((value) => typeof value === "string" && value.length > 0)) {
+        throw new PersistenceLifecycleError("ownership required", "ERR_PRISM_LIFECYCLE_OWNERSHIP");
+    }
+}
+function assertReason(reason) {
+    if (typeof reason !== "string" || !reason.trim()) {
+        throw new PersistenceLifecycleError("reason is required", "ERR_PRISM_LIFECYCLE_HOLD");
+    }
+    if (Buffer.byteLength(reason, "utf8") > HARD_MAX_HOLD_REASON_BYTES) {
+        throw new PersistenceLifecycleError("reason exceeds limit", "ERR_PRISM_LIFECYCLE_HOLD");
+    }
+    return reason;
+}
+function pageLimit(limit) {
+    const resolved = limit ?? DEFAULT_LIFECYCLE_PAGE_SIZE;
+    if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > HARD_LIFECYCLE_PAGE_SIZE) {
+        throw new PersistenceLifecycleError(`limit must be 1..${HARD_LIFECYCLE_PAGE_SIZE}`, "ERR_PRISM_LIFECYCLE_LIMITS");
+    }
+    return resolved;
+}
+function quotaKey(ownership, kind) {
+    return `${ownership.tenantId ?? ""}\0${ownership.accountId ?? ""}\0${ownership.userId ?? ""}\0${kind}`;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+//# sourceMappingURL=persistence-lifecycle.js.map

package/dist/providers/openai-compatible.d.ts

@@ -1,9 +1,13 @@
-import type { AIProvider } from "../contracts.js";
+import type { AIProvider, ProviderRequest } from "../contracts.js";
 import { type CredentialValueSource } from "../credentials.js";
 export interface OpenAICompatibleProviderOptions {
     readonly id?: string;
     readonly baseUrl: string;
     readonly apiKey?: CredentialValueSource;
     readonly fetch?: typeof fetch;
+    /** Override chat-completions URL (default `${baseUrl}/chat/completions`). */
+    readonly chatCompletionsUrl?: string | ((request: ProviderRequest) => string);
+    /** Default `bearer`. Azure resource keys use `api-key`; host-signed fetches may use `none`. */
+    readonly authStyle?: "bearer" | "api-key" | "none";
 }
 export declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): AIProvider;