@arnilo/prism 0.8.0 → 0.10.0

package/dist/guardrails.js

@@ -1,6 +1,44 @@
+import { GuardrailPackError } from "./guardrail-packs/errors.js";
+export { GuardrailPackError } from "./guardrail-packs/errors.js";
+import { BUILT_IN_GUARDRAIL_PACKS } from "./guardrail-packs/index.js";
 export const MAX_GUARDRAIL_CONCURRENCY = 16;
 const MAX_REASON_BYTES = 4 * 1024;
 const MAX_METADATA_BYTES = 16 * 1024;
+/** Guardrail pack compile bounds (plan 092 Task 2). All ceilings are config-shape limits, not runtime budgets. */
+export const MAX_GUARDRAIL_PACKS = 8;
+export const MAX_GUARDRAIL_PACK_RULES = 64;
+const MAX_PACK_ID_BYTES = 96;
+const MAX_RULE_ID_BYTES = 96;
+const MAX_RULE_REASON_BYTES = 512;
+const MAX_RULE_ARG_PATHS = 8;
+const MAX_PATTERN_BYTES = 4 * 1024;
+const MAX_ARG_SCAN_DEPTH = 8;
+const MAX_ARG_SCAN_STRINGS = 64;
+const MAX_ARG_STRING_BYTES = 16 * 1024;
+const MAX_PACK_NAME_BYTES = 128;
+const OBSERVE_RULE_ID = "observe";
+/** Bytes allowed for a rule-naming refusal line, so no rule text can grow a model or host message. */
+const MAX_GUARDRAIL_REFUSAL_BYTES = 200;
+/**
+ * Plan 104 T4/T6: the bounded, redacted refusal line for a terminal record that came from a compiled
+ * pack rule — `<prefix> by guardrail rule pack:<pack>/<rule>`, plus the pack's own reason when it set
+ * one — or `undefined` for any other guardrail, so the caller keeps its own neutral text. Only the
+ * compiler writes the `pack`/`rule` metadata, so a host-written guardrail named `pack:…` is never
+ * presented as a pack rule. Reasons are redacted where the record is built, pack names are
+ * compiler-bounded to 128 bytes (the identity always survives the cap), and a long reason is
+ * truncated, so the same derivation serves the tool refusal and decision-time revalidation.
+ */
+export function guardrailRefusalText(record, prefix = "Blocked") {
+    const pack = record.metadata?.pack;
+    const rule = record.metadata?.rule;
+    if (typeof pack !== "string" || typeof rule !== "string")
+        return undefined;
+    const line = `${prefix} by guardrail rule ${record.guardrail}`;
+    // The compiler synthesizes `guardrail pack rule <pack>/<rule>` when the rule set no reason; the
+    // identity already implies it, so only a real reason is appended.
+    const text = record.reason && record.reason !== `guardrail pack rule ${pack}/${rule}` ? `${line}: ${record.reason}` : line;
+    return boundText(text, MAX_GUARDRAIL_REFUSAL_BYTES);
+}
 export class GuardrailError extends Error {
     code;
     record;
@@ -60,6 +98,345 @@ export function assertGuardrailsAllowed(result) {
     if (result.terminal)
         throw new GuardrailError(result.terminal);
 }
+const EMPTY_COMPILED_PACKS = { guardrails: undefined, packs: [], snapshotState: () => undefined };
+/**
+ * Compiles `guardrailPacks` config onto the existing tool interception seams: one `tool_input`
+ * guardrail per rule (`name = pack:<pack>/<rule>`), plus one `tool_output` recorder for packs that
+ * observe results. Compiled once per session — patterns are compiled here, never per tool call.
+ * Throws `GuardrailPackError` on malformed config (fail closed); returns `undefined` when unset.
+ */
+export function compileGuardrailPacks(refs, registry = BUILT_IN_GUARDRAIL_PACKS) {
+    return compileGuardrailPacksWithState(refs, registry).guardrails;
+}
+/**
+ * Plan 104 Task 2: the internal compile entry behind `compileGuardrailPacks`. Passing `initial`
+ * marks a durable restore — rows must then come from the installed registry, match its version, and
+ * parse through the pack's own state codec, so a mismatch fails closed instead of restoring a
+ * weaker policy. `snapshotState` is the checkpoint-side counterpart.
+ */
+export function compileGuardrailPacksWithState(refs, registry = BUILT_IN_GUARDRAIL_PACKS, initial) {
+    const packs = resolveGuardrailPacks(refs, registry, initial);
+    if (packs.length === 0)
+        return EMPTY_COMPILED_PACKS;
+    const toolInput = [];
+    const toolOutput = [];
+    const askGate = [];
+    const askBlocks = [];
+    for (const pack of packs) {
+        if (pack.observe)
+            toolOutput.push(observeGuardrail(pack, pack.observe, pack.state));
+        for (const resolved of pack.rules) {
+            if (resolved.action === "ask") {
+                // Plan 104 T3: `ask` is not an ordinary stage decision. A run that can suspend gates the
+                // call at charge time (`interrupt` is the record meaning "awaiting a decision"), while a run
+                // that cannot suspend evaluates the same rule as a plain block through `activeGuardrails`.
+                askGate.push(ruleGuardrail(pack, resolved, pack.state, "interrupt"));
+                askBlocks.push(ruleGuardrail(pack, resolved, pack.state, "block"));
+                continue;
+            }
+            toolInput.push(ruleGuardrail(pack, resolved, pack.state));
+        }
+    }
+    return {
+        guardrails: toolOutput.length > 0 ? { toolInput, toolOutput } : { toolInput },
+        packs: packs.map((pack) => pack.row),
+        ...(askGate.length > 0 ? { askGate: { toolInput: askGate }, askBlocks: { toolInput: askBlocks } } : {}),
+        snapshotState: () => {
+            const state = {};
+            for (const pack of packs) {
+                // Plan 104 T3: an inline pack now rides the checkpoint as rules, so only the rule shapes
+                // that cannot round-trip matter: a closure has no JSON form, and a `RegExp` serializes to
+                // `{}`, which would restore as an invalid (or, worse, absent) pattern.
+                const unpersistable = pack.inline
+                    ? pack.rules.find((resolved) => resolved.rule.deny !== undefined || resolved.rule.pattern instanceof RegExp)
+                    : undefined;
+                if (unpersistable) {
+                    throw new GuardrailPackError(`guardrail pack "${pack.id}" rule "${unpersistable.rule.id}" cannot be persisted (deny predicate or RegExp pattern); use a pattern string or a registered pack id when \`persistSessionState\` is on`);
+                }
+                const snapshot = pack.stateCodec?.snapshot(pack.state);
+                if (snapshot !== undefined)
+                    state[pack.id] = snapshot;
+            }
+            return Object.keys(state).length > 0 ? state : undefined;
+        },
+    };
+}
+/** Stable identity rows for the same config `compileGuardrailPacks` accepts (no state, no guardrails built). */
+export function describeGuardrailPacks(refs, registry = BUILT_IN_GUARDRAIL_PACKS) {
+    const rows = [];
+    for (const pack of resolveGuardrailPacks(refs, registry)) {
+        if (pack.observe)
+            rows.push({ name: packRuleName(pack.id, OBSERVE_RULE_ID), stage: "tool_output", revision: packRevision(pack) });
+        for (const resolved of pack.rules)
+            rows.push({ name: packRuleName(pack.id, resolved.rule.id), stage: "tool_input", revision: packRevision(pack) });
+    }
+    return rows;
+}
+function packRevision(pack) {
+    return `${pack.id}@${pack.version}`;
+}
+function packRuleName(packId, ruleId) {
+    return `pack:${packId}/${ruleId}`;
+}
+function resolveGuardrailPacks(refs, registry, initial) {
+    if (refs === undefined)
+        return [];
+    if (!Array.isArray(refs))
+        throw new GuardrailPackError("guardrailPacks must be an array of pack ids or pack input objects");
+    if (refs.length > MAX_GUARDRAIL_PACKS)
+        throw new GuardrailPackError(`guardrailPacks accepts at most ${MAX_GUARDRAIL_PACKS} packs`);
+    const restoring = initial !== undefined;
+    const seenPacks = new Set();
+    return refs.map((ref) => {
+        const input = (typeof ref === "string" ? { id: ref } : ref) ?? {};
+        if (typeof input.id !== "string" || !input.id.trim() || byteLength(input.id) > MAX_PACK_ID_BYTES) {
+            throw new GuardrailPackError(`guardrail pack ids must be non-empty strings of at most ${MAX_PACK_ID_BYTES} bytes`);
+        }
+        if (seenPacks.has(input.id))
+            throw new GuardrailPackError(`duplicate guardrail pack id "${input.id}"`);
+        seenPacks.add(input.id);
+        if (input.version !== undefined && (!Number.isSafeInteger(input.version) || input.version < 1)) {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" version must be a positive integer`);
+        }
+        const definition = registry.get(input.id);
+        if (definition === undefined && input.rules === undefined) {
+            throw unknownGuardrailPack(input.id, registry);
+        }
+        // A restored checkpoint replays rows, so a registered id must still match its installed version
+        // while an inline pack needs its pattern rules back (a closure cannot ride a checkpoint, and a
+        // pack replaying without it would enforce less than it did).
+        if (restoring) {
+            if (input.rules === undefined) {
+                if (definition === undefined)
+                    throw unknownGuardrailPack(input.id, registry);
+                if (input.version !== definition.version) {
+                    throw new GuardrailPackError(`guardrail pack "${input.id}" was persisted at version ${input.version} but the installed version is ${definition.version}`);
+                }
+            }
+            else if (input.rules.some((rule) => rule?.deny !== undefined)) {
+                throw new GuardrailPackError(`persisted guardrail pack "${input.id}" carries a deny predicate; only pattern rules can be restored`);
+            }
+        }
+        let built;
+        if (input.rules !== undefined) {
+            if (input.options !== undefined)
+                throw new GuardrailPackError(`inline guardrail pack "${input.id}" cannot set options`);
+            built = { rules: input.rules };
+        }
+        else {
+            if (definition === undefined)
+                throw unknownGuardrailPack(input.id, registry);
+            built = definition.build(Object.freeze({ ...input.options }));
+        }
+        if (!built || !Array.isArray(built.rules) || built.rules.length === 0) {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" must declare at least one rule`);
+        }
+        if (built.rules.length > MAX_GUARDRAIL_PACK_RULES) {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" accepts at most ${MAX_GUARDRAIL_PACK_RULES} rules`);
+        }
+        if (built.observe !== undefined && typeof built.observe !== "function") {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" observe must be a function`);
+        }
+        if (built.state !== undefined && (typeof built.state.snapshot !== "function" || typeof built.state.parse !== "function")) {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" state codec must declare snapshot and parse`);
+        }
+        const seenRules = new Set();
+        const rules = built.rules.map((rule) => resolveRule(input.id, rule, seenRules));
+        if (built.observe && byteLength(packRuleName(input.id, OBSERVE_RULE_ID)) > MAX_PACK_NAME_BYTES) {
+            throw new GuardrailPackError(`guardrail pack "${input.id}" name exceeds ${MAX_PACK_NAME_BYTES} bytes`);
+        }
+        const version = input.version ?? definition?.version ?? 1;
+        const state = {};
+        const persisted = initial === undefined ? undefined : initial[input.id];
+        if (persisted !== undefined) {
+            if (built.state === undefined) {
+                throw new GuardrailPackError(`guardrail pack "${input.id}" has persisted state but declares no state codec`);
+            }
+            Object.assign(state, built.state.parse(persisted));
+        }
+        return {
+            id: input.id,
+            version,
+            rules,
+            state,
+            inline: input.rules !== undefined,
+            row: {
+                id: input.id,
+                version,
+                ...(input.options !== undefined ? { options: input.options } : {}),
+                ...(input.rules !== undefined ? { rules: input.rules } : {}),
+            },
+            ...(built.observe ? { observe: built.observe } : {}),
+            ...(built.state !== undefined ? { stateCodec: built.state } : {}),
+        };
+    });
+}
+function unknownGuardrailPack(id, registry) {
+    return new GuardrailPackError(`unknown guardrail pack "${id}"; known packs: ${[...registry.keys()].join(", ") || "none"}`);
+}
+function resolveRule(packId, rule, seenRules) {
+    const where = `guardrail pack "${packId}"`;
+    if (!rule || typeof rule.id !== "string" || !rule.id.trim() || byteLength(rule.id) > MAX_RULE_ID_BYTES) {
+        throw new GuardrailPackError(`${where} rule ids must be non-empty strings of at most ${MAX_RULE_ID_BYTES} bytes`);
+    }
+    if (seenRules.has(rule.id))
+        throw new GuardrailPackError(`${where} has a duplicate rule id "${rule.id}"`);
+    seenRules.add(rule.id);
+    const action = rule.action ?? "deny";
+    if (action !== "deny" && action !== "tripwire" && action !== "ask") {
+        throw new GuardrailPackError(`${where} rule "${rule.id}" action must be "deny", "tripwire", or "ask"`);
+    }
+    if (action === "ask" && rule.deny !== undefined) {
+        throw new GuardrailPackError(`${where} rule "${rule.id}" action "ask" requires "pattern": an opaque deny predicate cannot raise an approval`);
+    }
+    const hasPattern = rule.pattern !== undefined;
+    const hasDeny = rule.deny !== undefined;
+    if (hasPattern === hasDeny) {
+        throw new GuardrailPackError(`${where} rule "${rule.id}" requires exactly one of "pattern" or "deny"`);
+    }
+    if (hasDeny && typeof rule.deny !== "function")
+        throw new GuardrailPackError(`${where} rule "${rule.id}" deny must be a function`);
+    if (rule.reason !== undefined && (typeof rule.reason !== "string" || byteLength(rule.reason) > MAX_RULE_REASON_BYTES)) {
+        throw new GuardrailPackError(`${where} rule "${rule.id}" reason must be a string of at most ${MAX_RULE_REASON_BYTES} bytes`);
+    }
+    let tools;
+    if (rule.tool !== undefined) {
+        tools = typeof rule.tool === "string" ? [rule.tool] : [...rule.tool];
+        if (tools.length === 0 || tools.length > MAX_GUARDRAIL_PACK_RULES || tools.some((name) => typeof name !== "string" || !name.trim())) {
+            throw new GuardrailPackError(`${where} rule "${rule.id}" tool must be a non-empty tool name or array of names`);
+        }
+    }
+    if (rule.argPath !== undefined) {
+        const paths = typeof rule.argPath === "string" ? [rule.argPath] : [...rule.argPath];
+        if (paths.length === 0 || paths.length > MAX_RULE_ARG_PATHS || paths.some((path) => typeof path !== "string" || !path.trim())) {
+            throw new GuardrailPackError(`${where} rule "${rule.id}" argPath must be a non-empty dot path or array of paths`);
+        }
+    }
+    if (byteLength(packRuleName(packId, rule.id)) > MAX_PACK_NAME_BYTES) {
+        throw new GuardrailPackError(`${where} rule "${rule.id}" name exceeds ${MAX_PACK_NAME_BYTES} bytes`);
+    }
+    return {
+        rule,
+        action,
+        reason: rule.reason ?? `guardrail pack rule ${packId}/${rule.id}`,
+        ...(tools ? { tools } : {}),
+        ...(hasPattern ? { regex: compileRulePattern(packId, rule.id, rule.pattern) } : {}),
+    };
+}
+function compileRulePattern(packId, ruleId, pattern) {
+    const where = `guardrail pack "${packId}" rule "${ruleId}"`;
+    if (pattern instanceof RegExp)
+        return new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, ""));
+    if (typeof pattern !== "string" || !pattern)
+        throw new GuardrailPackError(`${where} pattern must be a non-empty string or RegExp`);
+    if (byteLength(pattern) > MAX_PATTERN_BYTES)
+        throw new GuardrailPackError(`${where} pattern exceeds ${MAX_PATTERN_BYTES} bytes`);
+    try {
+        return new RegExp(pattern);
+    }
+    catch (error) {
+        throw new GuardrailPackError(`${where} has an invalid pattern`, { cause: error });
+    }
+}
+function ruleGuardrail(pack, resolved, state, askAction = "interrupt") {
+    return {
+        name: packRuleName(pack.id, resolved.rule.id),
+        revision: packRevision(pack),
+        stage: "tool_input",
+        evaluate(context) {
+            if (resolved.tools && !resolved.tools.includes(context.toolName ?? ""))
+                return { action: "allow" };
+            const args = context.value.arguments;
+            const matched = resolved.rule.deny
+                ? Boolean(resolved.rule.deny(args, ruleContext(context, state)))
+                : patternMatches(resolved.regex, argumentStrings(args, resolved.rule.argPath));
+            if (!matched)
+                return { action: "allow" };
+            return {
+                // Pack vocabulary is `deny`/`ask`; the core guardrail actions are `block`/`interrupt`.
+                action: resolved.action === "deny" ? "block" : resolved.action === "ask" ? askAction : "tripwire",
+                reason: resolved.reason,
+                metadata: { pack: pack.id, rule: resolved.rule.id, version: pack.version },
+            };
+        },
+    };
+}
+function observeGuardrail(pack, observe, state) {
+    return {
+        name: packRuleName(pack.id, OBSERVE_RULE_ID),
+        revision: packRevision(pack),
+        stage: "tool_output",
+        evaluate(context) {
+            observe(state, context.value, ruleContext(context, state));
+            return { action: "allow" };
+        },
+    };
+}
+function ruleContext(context, state) {
+    return {
+        toolName: context.toolName ?? "",
+        toolCallId: context.toolCallId ?? "",
+        sessionId: context.sessionId,
+        runId: context.runId,
+        metadata: context.metadata,
+        state,
+    };
+}
+function patternMatches(regex, values) {
+    for (const value of values) {
+        if (regex.test(value.length > MAX_ARG_STRING_BYTES ? value.slice(0, MAX_ARG_STRING_BYTES) : value))
+            return true;
+    }
+    return false;
+}
+function argumentStrings(args, argPath) {
+    if (argPath === undefined) {
+        const all = [];
+        for (const value of Object.values(args))
+            pushStrings(value, all, 0);
+        return all;
+    }
+    const out = [];
+    for (const path of typeof argPath === "string" ? [argPath] : argPath) {
+        walkPath(args, path.split("."), out);
+        if (out.length >= MAX_ARG_SCAN_STRINGS)
+            break;
+    }
+    return out;
+}
+function walkPath(value, segments, out) {
+    if (out.length >= MAX_ARG_SCAN_STRINGS)
+        return;
+    if (segments.length === 0) {
+        pushStrings(value, out, 0);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            walkPath(item, segments, out);
+        return;
+    }
+    if (value && typeof value === "object") {
+        walkPath(value[segments[0]], segments.slice(1), out);
+    }
+}
+function pushStrings(value, out, depth) {
+    if (out.length >= MAX_ARG_SCAN_STRINGS || depth > MAX_ARG_SCAN_DEPTH)
+        return;
+    if (typeof value === "string") {
+        out.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            pushStrings(item, out, depth + 1);
+        return;
+    }
+    if (value && typeof value === "object") {
+        for (const item of Object.values(value))
+            pushStrings(item, out, depth + 1);
+    }
+}
 function stageGuards(guardrails, stage) {
     if (!guardrails)
         return [];

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export { resolveAgentDefinition } from "./agent-definitions.js";
 export type { AgentEventSourceErrorCode } from "./agent-event-source.js";
-export { AgentEventSourceError, createMemoryAgentEventSource } from "./agent-event-source.js";
+export { AgentEventSourceError, createMemoryAgentEventSource, isTerminalAgentEventType } from "./agent-event-source.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop, } from "./agent-loops.js";
 export type { AgentRunLifecycle, AgentRunLifecycleAgent, AgentRunLifecycleOptions, AgentRunLifecycleRequest, AgentRunLifecycleStreamRequest, } from "./agent-run-lifecycle.js";
 export { createAgentRunLifecycle } from "./agent-run-lifecycle.js";
 export type { PendingToolCall, StoredAgentRunState } from "./agent-run-state.js";
-export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, agentFingerprint, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, loadAgentRunState, } from "./agent-run-state.js";
+export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, agentFingerprint, boundCheckpointMetadata, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, loadAgentRunState, MAX_AGENT_RUN_METADATA_BYTES, readCheckpointMetadata, resolveCheckpointMetadata, } from "./agent-run-state.js";
 export { createAgent, createAgentSession, resumeAgentRun, resumeAgentRunStream } from "./agents.js";
 export type { ArtifactApproval, ArtifactApprovalState, ArtifactBodyErrorCode, ArtifactBodyPresignOptions, ArtifactBodyRef, ArtifactBodyStore, ArtifactBodyTransferOptions, ArtifactCitation, ArtifactDecisionState, ArtifactDeliveryToken, ArtifactRecord, ArtifactRevision, CitationIntegrityReason, CitationIntegrityResult, CitationLiveSource, CitationSupport, } from "./artifacts.js";
 export { ARTIFACT_BODY_ERROR_CODES, ARTIFACT_CHECKPOINT_NAMESPACE, ArtifactBodyStoreError, ArtifactError, approvalEvidenceIntact, artifactApprovalState, artifactCheckpointKey, checkCitationIntegrity, citationBindingDigest, HARD_CITATION_EXCERPT_BYTES, } from "./artifacts.js";
@@ -17,6 +17,8 @@ export type { CacheTelemetry, CacheTelemetryOptions, CacheTelemetryReport, Cache
 export { CACHE_TELEMETRY_OVERFLOW_KEY, CacheTelemetryError, createCacheTelemetry, DEFAULT_CACHE_TELEMETRY_CAP, } from "./cache-telemetry.js";
 export type { ProviderCapture, ProviderCaptureEntry, ProviderCaptureOptions, ProviderCapturePolicy } from "./capture.js";
 export { createProviderCapture } from "./capture.js";
+export type { CheckpointRestoreAudit, CheckpointRestoreAuditEntry, CheckpointRestoreHook, RunCheckpointRestoreHooksOptions, } from "./checkpoint-restore.js";
+export { CheckpointRestoreError, DEFAULT_CHECKPOINT_RESTORE_TIMEOUT_MS, runCheckpointRestoreHooks } from "./checkpoint-restore.js";
 export type { MemoryCheckpointStoreOptions } from "./checkpoints.js";
 export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpointStore } from "./checkpoints.js";
 export type { DefaultCompactionStrategyOptions } from "./compaction.js";
@@ -28,7 +30,7 @@ export { assertDeclaredMediaTypeMatches, assertMediaBlocksWithinBounds, assertMe
 export type { ContextBudget, ContextBudgetMessageGroups, ContextBudgetOmission, ContextBudgetOmissionKind, ContextBudgetReport, TokenEstimator, } from "./context-budget.js";
 export { applyContextBudget, CONTEXT_BUDGET_ERROR_CODE, CONTEXT_BUDGET_REPORT_METADATA_KEY, ContextBudgetError, DEFAULT_MAX_CONTEXT_BUDGET_OMISSIONS, estimateAssemblyTokens, estimateMessageBytes, estimateMessageTokens, estimateTextBytes, estimateTextTokens, getContextBudgetReport, HARD_MAX_CONTEXT_BUDGET_BYTES, HARD_MAX_CONTEXT_BUDGET_OMISSIONS, HARD_MAX_CONTEXT_BUDGET_TOKENS, isContextBudgetError, resolveContextBudget, } from "./context-budget.js";
 export type * from "./contracts.js";
-export type { ApprovalOutcome, AttentionCompiler, AttentionCompilerContext, AttentionCompilerOptions, AttentionCompilerSetting, AttentionInputCapOptions, AttentionReport, CompactionTrigger, CompactionTriggerContext, DecisionScope, NestedRunApproval, NestedRunOutcome, NestedRunRef, PendingDecision, PendingDecisionKind, ProviderResolver, RealtimeCaps, RealtimeEvent, RealtimeSession, RealtimeSessionFactory, RealtimeSessionOptions, ResolveShouldCompactInput, ResolveShouldCompactOptions, ResumeNestedRun, RunDecision, RunLimitCounters, RunLimitName, SecureAgentOptions, StickyDecision, ToolCallAuthority, ToolEffectClassifier, ToolEffectDeclaration, ToolEffectIdempotency, ToolEffectKey, ToolEffectKind, ToolEffectRecord, ToolEffectStatus, ToolEffectStore, ToolEffectTransition, ToolElicitationRequest, } from "./contracts.js";
+export type { ApprovalOutcome, AttentionCompiler, AttentionCompilerContext, AttentionCompilerOptions, AttentionCompilerSetting, AttentionInputCapOptions, AttentionReport, CompactionTrigger, CompactionTriggerContext, ContextMeter, DecisionScope, ModelFamily, NestedRunApproval, NestedRunOutcome, NestedRunRef, PendingDecision, PendingDecisionKind, ProviderResolver, RealtimeCaps, RealtimeEvent, RealtimeSession, RealtimeSessionFactory, RealtimeSessionOptions, ResolveShouldCompactInput, ResolveShouldCompactOptions, ResumeNestedRun, RunDecision, RunLimitCounters, RunLimitName, SecureAgentOptions, StickyDecision, TokenEstimate, TokenEstimateConfidence, ToolCallAuthority, ToolEffectClassifier, ToolEffectDeclaration, ToolEffectIdempotency, ToolEffectKey, ToolEffectKind, ToolEffectRecord, ToolEffectStatus, ToolEffectStore, ToolEffectTransition, ToolElicitationRequest, } from "./contracts.js";
 export { AgentDecisionError, AgentDelegationSuspendedError, AgentLoopStateError, AgentRunError, AgentRunStateError, assertBatchJobsSupported, assertCompactionTrigger, assertEmbeddingsSupported, assertImageGenerationSupported, assertModerationSupported, assertSessionMetadataKey, assertSpeechSupported, assertTranscriptionSupported, assertVideoGenerationSupported, BatchJobsError, DEFAULT_MAX_PENDING_DECISIONS, DEFAULT_MAX_PENDING_STEER_BYTES, DEFAULT_MAX_PENDING_STEERS, DEFAULT_MAX_SESSION_SEARCH_CURSOR_BYTES, DEFAULT_MAX_SESSION_SEARCH_FTS_CANDIDATES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_QUERY_BYTES, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, DEFAULT_MAX_STICKY_DECISIONS, DEFAULT_SESSION_SEARCH_LIMIT, DEFAULT_SNAPSHOT_CACHE_TTL_MS, EmbeddingsError, HARD_MAX_ACTION_CONSTRAINT_BYTES, HARD_MAX_ACTION_CONSTRAINTS, HARD_MAX_DECISION_REASON_BYTES, HARD_MAX_ELICITATION_BYTES, HARD_MAX_PENDING_DECISIONS, HARD_MAX_PENDING_STEER_BYTES, HARD_MAX_PENDING_STEERS, HARD_MAX_SESSION_SEARCH_CURSOR_BYTES, HARD_MAX_SESSION_SEARCH_FTS_CANDIDATES, HARD_MAX_SESSION_SEARCH_LIMIT, HARD_MAX_SESSION_SEARCH_LINEAR_BYTES, HARD_MAX_SESSION_SEARCH_LINEAR_ENTRIES, HARD_MAX_SESSION_SEARCH_LINEAR_SESSIONS, HARD_MAX_SESSION_SEARCH_QUERY_BYTES, HARD_MAX_SESSION_SEARCH_SNIPPET_BYTES, HARD_MAX_SNAPSHOT_CACHE_TTL_MS, HARD_MAX_STICKY_DECISIONS, ImageGenerationError, isBatchJobTerminal, isSessionAppendConflict, isSessionEntryKind, isSessionMetadataConflict, isSessionSearchUnsupported, MAX_ACTION_CONSTRAINT_BYTES, MAX_ACTION_CONSTRAINTS, MAX_ATTRIBUTION_DEPTH, MAX_DECISION_REASON_BYTES, MAX_ELICITATION_BYTES, ModerationError, modelSupportsBatchJobs, modelSupportsEmbeddings, modelSupportsImageGeneration, modelSupportsModeration, modelSupportsSpeech, modelSupportsTranscription, modelSupportsVideoGeneration, pollBatch, resolveSessionSearchQuery, resolveShouldCompact, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_KINDS, SESSION_ENTRY_SCHEMA_VERSION, SESSION_METADATA_CONFLICT_CODE, SESSION_SEARCH_UNSUPPORTED_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionMetadataConflictError, SessionSearchUnsupportedError, SpeechError, TranscriptionError, VideoGenerationError, } from "./contracts.js";
 export { parseAgentFile, parseSkillFile } from "./contribution-parsing.js";
 export type { ContributionRegistries, ContributionRegistriesOptions, ContributionRegistry, ContributionRegistryOptions, } from "./contributions.js";
@@ -47,14 +49,15 @@ export type { ClaimGroundingEvidence, ClaimGroundingEvidenceExtractor, ClaimGrou
 export { createClaimGroundingGuardrail } from "./evidence-grounding.js";
 export type { ExecutionAction, ExecutionDecision, ExecutionPolicy, ExecutionRisk } from "./execution-policy.js";
 export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
-export type { ActivatedKernelConfig, ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions, ExtensionLoadPolicy, LoadedExtension, } from "./extensions.js";
-export { activateKernel, createExtensionEventBus, createExtensionKernel } from "./extensions.js";
+export type { ActivatedKernelConfig, AgentEventBridgeOptions, ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions, ExtensionLoadPolicy, LoadedExtension, } from "./extensions.js";
+export { activateKernel, createExtensionEventBus, createExtensionKernel, forwardAgentEvents } from "./extensions.js";
 export type { MemoryRunFeedbackStoreOptions, PrepareRunFeedbackOptions, RunFeedbackLimits, RunFeedbackRun, RunFeedbackRunResolver, } from "./feedback.js";
 export { createMemoryRunFeedbackStore, prepareRunFeedback, RunFeedbackError, requireRunFeedbackOwnership, runFeedbackPageLimit, } from "./feedback.js";
 export type { ApplyFieldPolicyOptions, AuditFieldRedaction, AuditFieldRedactorLike, AuditFieldRedactorOptions, FieldPolicy, FieldPolicyAction, FieldPolicyDecision, FieldPolicyInput, ProtectedFieldPolicyOptions, } from "./field-policy.js";
 export { ALLOW_FIELD_POLICY, applyFieldPolicy, createAuditFieldRedactor, createProtectedFieldPolicy, FIELD_POLICY_LIMITS, FieldPolicyError, } from "./field-policy.js";
-export type { GuardrailRunResult, RunGuardrailsOptions, } from "./guardrails.js";
-export { assertGuardrailsAllowed, GuardrailError, MAX_GUARDRAIL_CONCURRENCY, runGuardrails } from "./guardrails.js";
+export { BUILT_IN_GUARDRAIL_PACK_IDS } from "./guardrail-packs/index.js";
+export type { GuardrailPackRow, GuardrailRunResult, RunGuardrailsOptions, } from "./guardrails.js";
+export { assertGuardrailsAllowed, compileGuardrailPacks, describeGuardrailPacks, GuardrailError, GuardrailPackError, MAX_GUARDRAIL_CONCURRENCY, MAX_GUARDRAIL_PACK_RULES, MAX_GUARDRAIL_PACKS, runGuardrails, } from "./guardrails.js";
 export type { AgentIdentity, AssertIdentityActiveOptions, IdentityLimits, IdentityVerifier, NarrowIdentityOptions, Principal, ResolvedIdentityLimits, } from "./identity.js";
 export { assertIdentityActive, assertIdentityMatchesOwnership, assertIdentityPropagation, DEFAULT_IDENTITY_LIMITS, HARD_IDENTITY_LIMITS, IdentityError, identityTelemetryAttributes, narrowIdentity, ownershipFromIdentity, resolveIdentityLimits, resolveRunIdentity, } from "./identity.js";
 export type { AgentInput, AssembleProviderInputOptions, DefaultInputBuildContext, DefaultInputBuilder, DefaultPromptBuilder, InputAttachment, PromptInstruction, PromptTemplateOptions, ResolveContextOptions, } from "./input.js";
@@ -64,8 +67,8 @@ export { resolveInstructionInjectors, runInstructionInjectors } from "./instruct
 export { createMemoryLeaseStore, LEASE_CONFLICT_CODE, LeaseConflictError } from "./leases.js";
 export type { ManifestContributionDeclaration, ManifestContributionKind, ManifestResourceDeclaration, PrismManifest } from "./manifests.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
-export type { Middleware, MiddlewareHookName, MiddlewareNext, MiddlewareRegistry, MiddlewareRegistryOptions } from "./middleware.js";
-export { createMiddlewareRegistry } from "./middleware.js";
+export type { BeforeProviderTurnPayload, DeterministicTurnAnswer, DeterministicTurnProvenance, Middleware, MiddlewareHookName, MiddlewareNext, MiddlewareRegistry, MiddlewareRegistryOptions, } from "./middleware.js";
+export { createMiddlewareRegistry, DeterministicTurnError } from "./middleware.js";
 export type { MockProviderOptions } from "./mock-provider.js";
 export { createMockProvider } from "./mock-provider.js";
 export type { ModelRegistry, ModelRegistryOptions } from "./models.js";
@@ -75,7 +78,7 @@ export { createProviderTurnMetadata, readProviderHttpStatus } from "./observabil
 export type { ApplyRetentionInput, ApplyRetentionResult, ConsumeTenantQuotaInput, ExportUnderHoldInput, LegalHoldExportItem, LegalHoldQuery, LegalHoldRecord, PersistenceLifecycleStore, PersistenceResourceKind, PutLegalHoldInput, ReleaseLegalHoldInput, SetTenantQuotaInput, TenantQuota, } from "./persistence-lifecycle.js";
 export { createMemoryPersistenceLifecycle, DEFAULT_LIFECYCLE_PAGE_SIZE, DEFAULT_MAX_HOLD_REASON_BYTES, HARD_LIFECYCLE_PAGE_SIZE, HARD_MAX_HOLD_REASON_BYTES, isResourceHeld, PersistenceLifecycleError, } from "./persistence-lifecycle.js";
 export { boundResponse, defaultResolver, isLoopbackAddress, isLoopbackHostname, normalizeHostname, type PinnedFetchOptions, pinnedFetch, raceAbort, requestPinned, resolvePinnedAddress, } from "./pinned-fetch.js";
-export { providerContentDelta, providerContinuationRequired, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, toolCallFromArgumentsText, } from "./provider-events.js";
+export { mapProviderStopReason, providerContentDelta, providerContinuationRequired, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, toolCallFromArgumentsText, } from "./provider-events.js";
 export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
 export type { ApplyDefaultProviderRequestOptionsContext, SessionCachePolicyOptions } from "./provider-request-policy.js";
 export { applyDefaultProviderRequestOptions, createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions, ProviderRequirementError, } from "./provider-request-policy.js";
@@ -123,8 +126,10 @@ export { createActiveToolSet, createSearchToolsTool, createToolSearchIndex, crea
 export type { DispatchToolCallOptions, ToolArgumentValidationError, ToolArgumentValidationResult, ToolArgumentValidator, ToolFilter, ToolFilterInput, ToolParameterValidatorOptions, ToolRegistryOptions, ToolValidator, } from "./tools.js";
 export { createToolParameterValidator, createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
 export { trimTrailingSlashes } from "./trim-trailing-slashes.js";
+export type { ModelFamilyTokens } from "./usage-estimation.js";
+export { MODEL_FAMILY_TOKENS, resolveModelFamily } from "./usage-estimation.js";
 export type { ResolvedUseCaseModel, ResolveUseCaseModelInput, UseCaseModelBinding, } from "./use-case-model.js";
 export { resolveUseCaseModel, resolveUseCaseModelBinding, useCaseCredentialProviderId, } from "./use-case-model.js";
 export declare const name = "prism";
-export declare const version = "0.8.0";
+export declare const version = "0.10.0";
 export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -1,14 +1,15 @@
 export { resolveAgentDefinition } from "./agent-definitions.js";
-export { AgentEventSourceError, createMemoryAgentEventSource } from "./agent-event-source.js";
+export { AgentEventSourceError, createMemoryAgentEventSource, isTerminalAgentEventType } from "./agent-event-source.js";
 export { dispatchToolCallsInOrder, generateValidateReviseLoop, isAgentLoopOptions, resolveLoop, resolveToolConcurrency, singleShotLoop, } from "./agent-loops.js";
 export { createAgentRunLifecycle } from "./agent-run-lifecycle.js";
-export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, agentFingerprint, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, loadAgentRunState, } from "./agent-run-state.js";
+export { AGENT_RUN_STATE_NAMESPACE, AGENT_RUN_STATE_SCHEMA_VERSION, agentFingerprint, boundCheckpointMetadata, DEFAULT_MAX_AGENT_RUN_STATE_BYTES, HARD_MAX_AGENT_RUN_STATE_BYTES, loadAgentRunState, MAX_AGENT_RUN_METADATA_BYTES, readCheckpointMetadata, resolveCheckpointMetadata, } from "./agent-run-state.js";
 export { createAgent, createAgentSession, resumeAgentRun, resumeAgentRunStream } from "./agents.js";
 export { ARTIFACT_BODY_ERROR_CODES, ARTIFACT_CHECKPOINT_NAMESPACE, ArtifactBodyStoreError, ArtifactError, approvalEvidenceIntact, artifactApprovalState, artifactCheckpointKey, checkCitationIntegrity, citationBindingDigest, HARD_CITATION_EXCERPT_BYTES, } from "./artifacts.js";
 export { ATTENTION_BUDGET_ERROR_CODE, AttentionBudgetError, createAttentionCompiler, createAttentionTruncationTrigger, DEFAULT_ATTENTION_COMPACT_RATIO, DEFAULT_ATTENTION_KEEP_LAST, DEFAULT_ATTENTION_RESERVE_TOKENS, DEFAULT_ATTENTION_THINKING_KEEP_TURNS, DEFAULT_ATTENTION_TRIGGER_RATIO, DEFAULT_ATTENTION_TRUNCATION_THRESHOLD, isAttentionBudgetError, resolveAttentionReserveTokens, resolveInputCap, resolveRunAttentionCompiler, } from "./attention-compiler.js";
 export { applyCacheControl, cacheHitRate, cacheSavings, cacheUsageReport, mapCacheRetention, resolveBreakpoint, sanitizeCacheKey, systemCacheControlField, } from "./cache-helpers.js";
 export { CACHE_TELEMETRY_OVERFLOW_KEY, CacheTelemetryError, createCacheTelemetry, DEFAULT_CACHE_TELEMETRY_CAP, } from "./cache-telemetry.js";
 export { createProviderCapture } from "./capture.js";
+export { CheckpointRestoreError, DEFAULT_CHECKPOINT_RESTORE_TIMEOUT_MS, runCheckpointRestoreHooks } from "./checkpoint-restore.js";
 export { CHECKPOINT_CONFLICT_CODE, CheckpointConflictError, createMemoryCheckpointStore } from "./checkpoints.js";
 export { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
 export { assertJsonObject, isJsonObject, loadConfigLayers, mergeConfigLayers } from "./config.js";
@@ -24,23 +25,24 @@ export { acceptDeviceChunk, assertDeviceAdmit, DEFAULT_DEVICE_MAX_CHUNK_BYTES, D
 export { createEventMultiplexer, EVENT_MULTIPLEXER_SINGLE_CONSUMER_CODE, EventMultiplexerError } from "./event-multiplexer.js";
 export { createClaimGroundingGuardrail } from "./evidence-grounding.js";
 export { applyExecutionDecision, assertExecutionAllowed, checkExecution, ExecutionDeniedError } from "./execution-policy.js";
-export { activateKernel, createExtensionEventBus, createExtensionKernel } from "./extensions.js";
+export { activateKernel, createExtensionEventBus, createExtensionKernel, forwardAgentEvents } from "./extensions.js";
 export { createMemoryRunFeedbackStore, prepareRunFeedback, RunFeedbackError, requireRunFeedbackOwnership, runFeedbackPageLimit, } from "./feedback.js";
 export { ALLOW_FIELD_POLICY, applyFieldPolicy, createAuditFieldRedactor, createProtectedFieldPolicy, FIELD_POLICY_LIMITS, FieldPolicyError, } from "./field-policy.js";
-export { assertGuardrailsAllowed, GuardrailError, MAX_GUARDRAIL_CONCURRENCY, runGuardrails } from "./guardrails.js";
+export { BUILT_IN_GUARDRAIL_PACK_IDS } from "./guardrail-packs/index.js";
+export { assertGuardrailsAllowed, compileGuardrailPacks, describeGuardrailPacks, GuardrailError, GuardrailPackError, MAX_GUARDRAIL_CONCURRENCY, MAX_GUARDRAIL_PACK_RULES, MAX_GUARDRAIL_PACKS, runGuardrails, } from "./guardrails.js";
 export { assertIdentityActive, assertIdentityMatchesOwnership, assertIdentityPropagation, DEFAULT_IDENTITY_LIMITS, HARD_IDENTITY_LIMITS, IdentityError, identityTelemetryAttributes, narrowIdentity, ownershipFromIdentity, resolveIdentityLimits, resolveRunIdentity, } from "./identity.js";
 export { assembleProviderInput, createDefaultInputBuilder, createDefaultPromptBuilder, EMPTY_TOOL_RESULT_TEXT, renderPromptTemplate, resolveContextProviders, } from "./input.js";
 export { resolveInstructionInjectors, runInstructionInjectors } from "./instruction-injection.js";
 export { createMemoryLeaseStore, LEASE_CONFLICT_CODE, LeaseConflictError } from "./leases.js";
 export { definePrismManifest, parsePrismManifest } from "./manifests.js";
-export { createMiddlewareRegistry } from "./middleware.js";
+export { createMiddlewareRegistry, DeterministicTurnError } from "./middleware.js";
 export { createMockProvider } from "./mock-provider.js";
 export { createModelRegistry } from "./models.js";
 export { abortableSleep, pollDeviceCodeToken, redactOAuthError, throwIfAborted, } from "./oauth-device-code.js";
 export { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
 export { createMemoryPersistenceLifecycle, DEFAULT_LIFECYCLE_PAGE_SIZE, DEFAULT_MAX_HOLD_REASON_BYTES, HARD_LIFECYCLE_PAGE_SIZE, HARD_MAX_HOLD_REASON_BYTES, isResourceHeld, PersistenceLifecycleError, } from "./persistence-lifecycle.js";
 export { boundResponse, defaultResolver, isLoopbackAddress, isLoopbackHostname, normalizeHostname, pinnedFetch, raceAbort, requestPinned, resolvePinnedAddress, } from "./pinned-fetch.js";
-export { providerContentDelta, providerContinuationRequired, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, toolCallFromArgumentsText, } from "./provider-events.js";
+export { mapProviderStopReason, providerContentDelta, providerContinuationRequired, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, toolCallFromArgumentsText, } from "./provider-events.js";
 export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
 export { applyDefaultProviderRequestOptions, createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions, ProviderRequirementError, } from "./provider-request-policy.js";
 export { canonicalizeJsonSchema } from "./providers/schema.js";
@@ -67,8 +69,9 @@ export { DEFAULT_TOOL_RESULT_FOLD_MAX_SUMMARY_BYTES, DEFAULT_TOOL_RESULT_FOLD_MI
 export { createActiveToolSet, createSearchToolsTool, createToolSearchIndex, createToolSearchState, DEFAULT_MAX_TOOLS_SEARCH_QUERY_BYTES, DEFAULT_TOOLS_SEARCH_TOP_K, HARD_MAX_TOOLS_INDEX, HARD_MAX_TOOLS_SEARCH_QUERY_BYTES, HARD_MAX_TOOLS_SEARCH_TOP_K, isToolDisclosureError, resolveToolsDisclosure, SEARCH_TOOLS_TOOL_NAME, scoreTools, selectDisclosedTools, TOOL_DISCLOSURE_ERROR_CODE, ToolDisclosureError, } from "./tool-search.js";
 export { createToolParameterValidator, createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
 export { trimTrailingSlashes } from "./trim-trailing-slashes.js";
+export { MODEL_FAMILY_TOKENS, resolveModelFamily } from "./usage-estimation.js";
 export { resolveUseCaseModel, resolveUseCaseModelBinding, useCaseCredentialProviderId, } from "./use-case-model.js";
 export const name = "prism";
-export const version = "0.8.0";
+export const version = "0.10.0";
 export const description = "Agent harness for AI providers, agents, sessions, and tools.";
 //# sourceMappingURL=index.js.map

package/dist/input.d.ts

@@ -1,4 +1,4 @@
-import { type AttentionStickyFrontier } from "./attention-compiler.js";
+import { type AttentionFoldLedger, type AttentionStickyFrontier } from "./attention-compiler.js";
 import { type ContextBudget } from "./context-budget.js";
 import type { AttentionCompiler, AttentionCompilerOptions, AttentionReport, ContentBlock, ContextBlock, ContextProvider, ContextResolutionContext, InputBuildContext, InputBuilder, InstructionInjector, JsonObject, Message, ModelConfig, PromptBuilder, PromptBuildRequest, ProviderRequest, ProviderRequestOptions, ResourceLoader, Skill, ToolDefinition, ToolResult } from "./contracts.js";
 import type { MiddlewareRegistry } from "./middleware.js";
@@ -65,6 +65,8 @@ export interface AssembleProviderInputOptions extends DefaultInputBuildContext {
     readonly skills?: readonly Skill[];
     readonly skillsDisclosure?: SkillsDisclosure;
     readonly loadedSkills?: LoadedSkillSet;
+    /** Run-owned append-only segments. Omit outside a session to retain existing assembly exactly. */
+    readonly tailSegments?: Map<string, Message>;
     readonly tools?: readonly ToolDefinition[];
     /** Tools disclosure: "search" narrows the disclosed tool list (activated ∪ top-k); default "all" is unchanged. */
     readonly toolsDisclosure?: ToolsDisclosure;
@@ -86,9 +88,14 @@ export interface AssembleProviderInputOptions extends DefaultInputBuildContext {
     readonly attentionCompiler?: AttentionCompilerOptions | AttentionCompiler;
     /** Per-session-leaf sticky frontier; omit for one-shot assemblies (no cross-turn stickiness). */
     readonly attentionSticky?: AttentionStickyFrontier;
+    /** Per-session folded bodies; omit to re-summarize every folded row on every turn. */
+    readonly attentionFold?: AttentionFoldLedger;
     /** Called once per *mutated* turn with the report, so a host can emit telemetry: under-ratio
      *  turns never call it, and it runs before `input_assembly` middleware. */
     readonly onAttentionReport?: (report: AttentionReport) => void;
+    /** Run input tokens already charged this run; feeds the `run_input_ratio` axis projection
+     *  (default 0). The run budget itself rides the resolved `AttentionCompiler` handle. */
+    readonly runInputTokens?: number;
 }
 export declare function createDefaultInputBuilder(): DefaultInputBuilder;
 export declare function resolveContextProviders(options: ResolveContextOptions): Promise<readonly ContextBlock[]>;