@arnilo/prism 0.0.1

package/dist/redaction.js

@@ -0,0 +1,68 @@
+const REDACTED = "[REDACTED]";
+export function createSecretRedactor(secrets) {
+    return { redact: (value) => redactSecrets(value, secrets) };
+}
+export function redactMessage(message, redactor) {
+    return redactor?.redact(message) ?? message;
+}
+export function redactAgentEvent(event, redactor) {
+    return redactor?.redact(event) ?? event;
+}
+export function redactSessionEntry(entry, redactor) {
+    return redactor?.redact(entry) ?? entry;
+}
+export function redactProviderRequest(request, redactor) {
+    return redactor?.redact(request) ?? request;
+}
+export function redactSecrets(value, secrets) {
+    const needles = secrets.filter((secret) => Boolean(secret));
+    if (needles.length === 0)
+        return value;
+    const redactString = (text) => needles.reduce((current, secret) => current.split(secret).join(REDACTED), text);
+    // ponytail: WeakSet cycle guard + leaf passthrough for Date/RegExp/ArrayBuffer/typed
+    // arrays. Map/Set are normalized to plain object/array so output stays JSON-shaped.
+    // Upgrade path: if callers need original Map/Set preserved, thread a mode flag.
+    const redact = (input, seen = new WeakSet()) => {
+        if (typeof input === "string")
+            return redactString(input);
+        if (input === null || typeof input !== "object")
+            return input;
+        if (input instanceof Date || input instanceof RegExp)
+            return input;
+        if (ArrayBuffer.isView(input) || input instanceof ArrayBuffer)
+            return input;
+        if (seen.has(input))
+            return "[Circular]";
+        seen.add(input);
+        if (Array.isArray(input))
+            return input.map((item) => redact(item, seen));
+        if (input instanceof Map)
+            return Object.fromEntries([...input].map(([key, item]) => [key, redact(item, seen)]));
+        if (input instanceof Set)
+            return [...input].map((item) => redact(item, seen));
+        return Object.fromEntries(Object.entries(input).map(([key, item]) => [key, redact(item, seen)]));
+    };
+    return redact(value);
+}
+export function errorToErrorInfo(error, secrets = []) {
+    const code = readErrorCode(error);
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: redactSecrets(error.message, secrets),
+            code,
+            cause: error.cause ? redactSecrets(String(error.cause), secrets) : undefined,
+        };
+    }
+    if (error && typeof error === "object" && "message" in error) {
+        return { message: redactSecrets(String(error.message), secrets), code };
+    }
+    return { message: redactSecrets(String(error), secrets), code };
+}
+function readErrorCode(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" || typeof code === "number" ? code : undefined;
+}
+//# sourceMappingURL=redaction.js.map

package/dist/resources.d.ts

@@ -0,0 +1,5 @@
+import { type PrismManifest } from "./manifests.js";
+import type { JsonObject, ResourceLoader, ResourceLoadContext } from "./contracts.js";
+export declare function loadTextResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<string>;
+export declare function loadJsonResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<JsonObject>;
+export declare function loadManifestResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<PrismManifest>;

package/dist/resources.js

@@ -0,0 +1,30 @@
+import { parsePrismManifest } from "./manifests.js";
+import { assertJsonObject } from "./config.js";
+import { assertPermission } from "./security.js";
+export async function loadTextResource(loader, uri, context) {
+    await assertPermission(context?.permission, { kind: "resource", action: "load", target: uri, metadata: context?.metadata });
+    const resource = await loader.load(uri, context);
+    if (resource.text !== undefined)
+        return resource.text;
+    if (resource.data !== undefined)
+        return new TextDecoder().decode(resource.data);
+    throw new Error(`Resource ${uri} has no text or data`);
+}
+export async function loadJsonResource(loader, uri, context) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await loadTextResource(loader, uri, context));
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON resource ${uri}: ${errorMessage(error)}`);
+    }
+    assertJsonObject(parsed, `resource ${uri}`);
+    return parsed;
+}
+export async function loadManifestResource(loader, uri, context) {
+    return parsePrismManifest(await loadJsonResource(loader, uri, context));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=resources.js.map

package/dist/retry.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorInfo, RetryDecision, RetryPolicy } from "./contracts.js";
+export interface DefaultRetryPolicyOptions {
+    readonly name?: string;
+    readonly maxAttempts?: number;
+    readonly baseDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly transientCodes?: readonly (string | number)[];
+}
+export declare function createDefaultRetryPolicy(options?: DefaultRetryPolicyOptions): RetryPolicy;
+export declare function isTransientErrorInfo(error: ErrorInfo, transientCodes?: ReadonlySet<string | number>): boolean;
+export declare function waitForRetry(decision: RetryDecision, signal?: AbortSignal): Promise<void>;

package/dist/retry.js

@@ -0,0 +1,48 @@
+import { setTimeout as sleep } from "node:timers/promises";
+const TRANSIENT_CODES = new Set([
+    "ETIMEDOUT",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EAI_AGAIN",
+    "ENOTFOUND",
+    "timeout",
+    "rate_limit",
+    "overloaded",
+    "temporarily_unavailable",
+    408,
+    409,
+    425,
+    429,
+    500,
+    502,
+    503,
+    504,
+]);
+export function createDefaultRetryPolicy(options = {}) {
+    const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+    const baseDelayMs = Math.max(0, options.baseDelayMs ?? 100);
+    const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? 1000);
+    const transientCodes = new Set([...TRANSIENT_CODES, ...(options.transientCodes ?? [])]);
+    return {
+        name: options.name ?? "default-retry",
+        decide(context) {
+            if (context.signal?.aborted || context.attempt >= maxAttempts || !isTransientErrorInfo(context.error, transientCodes))
+                return { retry: false };
+            return { retry: true, delayMs: Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, context.attempt - 1)) };
+        },
+    };
+}
+export function isTransientErrorInfo(error, transientCodes = TRANSIENT_CODES) {
+    if (error.name === "AbortError" || /aborted|abort/i.test(error.message))
+        return false;
+    if (error.code !== undefined && transientCodes.has(error.code))
+        return true;
+    return /timeout|temporar|rate.?limit|overload|unavailable/i.test(error.message);
+}
+export async function waitForRetry(decision, signal) {
+    const delayMs = Math.max(0, decision.delayMs ?? 0);
+    if (delayMs === 0)
+        return;
+    await sleep(delayMs, undefined, { signal, ref: false });
+}
+//# sourceMappingURL=retry.js.map

package/dist/rpc.d.ts

@@ -0,0 +1,18 @@
+import type { Readable, Writable } from "node:stream";
+import type { AgentSession, CommandDefinition } from "./contracts.js";
+export type RpcCommandName = "prompt" | "steer" | "followUp" | "abort" | "state" | "messages" | "setModel" | "compact" | "switchSession" | "forkSession" | "cloneSession" | "command";
+export interface RpcRequest {
+    readonly id: string | number;
+    readonly command: RpcCommandName;
+    readonly params?: Record<string, unknown>;
+}
+export interface RpcSessionFactory {
+    createSession(id?: string): AgentSession;
+    readonly commands?: readonly CommandDefinition[];
+}
+export interface RpcServerOptions extends RpcSessionFactory {
+    readonly stdin: Readable;
+    readonly stdout: Writable;
+}
+export declare function runRpcServer(options: RpcServerOptions): Promise<void>;
+export declare function parseRpcRequest(value: unknown): RpcRequest;

package/dist/rpc.js

@@ -0,0 +1,187 @@
+import { createInterface } from "node:readline";
+import { errorToErrorInfo } from "./redaction.js";
+export async function runRpcServer(options) {
+    const first = options.createSession();
+    const state = {
+        current: first,
+        sessions: new Map([[first.id, first]]),
+        commands: new Map((options.commands ?? []).map((command) => [command.name, command])),
+        createSession: options.createSession,
+    };
+    const activeRuns = new Map();
+    const lines = createInterface({ input: options.stdin, crlfDelay: Infinity });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        let raw;
+        let request;
+        try {
+            raw = JSON.parse(line);
+            request = parseRpcRequest(raw);
+        }
+        catch (error) {
+            write(options.stdout, { id: readRequestId(raw), ok: false, error: errorToErrorInfo(error) });
+            continue;
+        }
+        try {
+            await handleRequest(request, state, options.stdout, activeRuns);
+        }
+        catch (error) {
+            write(options.stdout, { id: request.id, ok: false, error: errorToErrorInfo(error) });
+        }
+    }
+    // Await any active runs before returning so callers do not lose final envelopes.
+    await Promise.allSettled([...activeRuns.values()].map((run) => run.promise));
+}
+export function parseRpcRequest(value) {
+    if (!isObject(value))
+        throw new Error("RPC request must be an object");
+    const { id, command, params } = value;
+    if (typeof id !== "string" && typeof id !== "number")
+        throw new Error("RPC request id must be a string or number");
+    if (!isCommand(command))
+        throw new Error(`Unknown RPC command: ${String(command)}`);
+    if (params !== undefined && !isObject(params))
+        throw new Error("RPC params must be an object");
+    return { id, command, params: params };
+}
+async function handleRequest(request, state, stdout, activeRuns) {
+    switch (request.command) {
+        case "prompt":
+        case "followUp": {
+            const input = stringParam(request.params, "input") ?? stringParam(request.params, "prompt");
+            if (!input)
+                throw new Error(`${request.command} requires params.input`);
+            const session = state.current;
+            const existing = activeRuns.get(session.id);
+            if (existing) {
+                write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(new Error(`Session ${session.id} already has an active run for request ${existing.requestId}`)) });
+                return;
+            }
+            const events = pumpEvents(session, stdout, request.id);
+            const promise = (async () => {
+                try {
+                    await session.run(input, runOptions(state, request.params));
+                }
+                finally {
+                    await events;
+                }
+                write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
+            })().catch((error) => {
+                write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(error) });
+            }).finally(() => {
+                activeRuns.delete(session.id);
+            });
+            activeRuns.set(session.id, { requestId: request.id, promise });
+            break;
+        }
+        case "steer":
+            throw new Error("steer is not supported by the current AgentSession runtime");
+        case "abort":
+            state.current.abort(stringParam(request.params, "reason"));
+            write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id } });
+            break;
+        case "state":
+            write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, sessions: [...state.sessions.keys()], model: state.model } });
+            break;
+        case "messages":
+            write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, entries: await state.current.entries() } });
+            break;
+        case "setModel":
+            state.model = modelParam(request.params);
+            write(stdout, { id: request.id, ok: true, result: { model: state.model } });
+            break;
+        case "compact":
+            write(stdout, { id: request.id, ok: true, result: await state.current.compact() });
+            break;
+        case "switchSession": {
+            const id = stringParam(request.params, "sessionId") ?? stringParam(request.params, "id");
+            if (!id)
+                throw new Error("switchSession requires params.sessionId");
+            const session = state.sessions.get(id) ?? makeSession(state, id);
+            state.current = session;
+            write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
+            break;
+        }
+        case "forkSession": {
+            const session = state.current.fork({ leafId: stringParam(request.params, "leafId") });
+            state.sessions.set(session.id, session);
+            state.current = session;
+            write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
+            break;
+        }
+        case "cloneSession": {
+            const session = await state.current.clone({ id: stringParam(request.params, "id"), leafId: stringParam(request.params, "leafId") });
+            state.sessions.set(session.id, session);
+            state.current = session;
+            write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
+            break;
+        }
+        case "command": {
+            const name = stringParam(request.params, "name");
+            if (!name)
+                throw new Error("command requires params.name");
+            const command = state.commands.get(name);
+            if (!command)
+                throw new Error(`Unknown command: ${name}`);
+            const args = objectParam(request.params, "args") ?? {};
+            const result = await command.execute(args, { sessionId: state.current.id });
+            write(stdout, { id: request.id, ok: true, result });
+            break;
+        }
+    }
+}
+function pumpEvents(session, stdout, requestId) {
+    return (async () => {
+        for await (const event of session.subscribe())
+            write(stdout, eventEnvelope(event, requestId));
+    })();
+}
+function eventEnvelope(event, requestId) {
+    const sessionId = "sessionId" in event ? event.sessionId : undefined;
+    const runId = "runId" in event ? event.runId : undefined;
+    return { type: "event", id: requestId, sessionId, runId, event };
+}
+function makeSession(state, id) {
+    const session = state.createSession(id);
+    state.sessions.set(session.id, session);
+    return session;
+}
+function runOptions(state, params) {
+    return { model: modelParam(params) ?? state.model, maxToolRounds: numberParam(params, "maxToolRounds") };
+}
+function modelParam(params) {
+    if (!params)
+        return undefined;
+    const model = params.model;
+    if (isObject(model) && typeof model.provider === "string" && typeof model.model === "string")
+        return model;
+    if (typeof model === "string")
+        return { provider: stringParam(params, "provider") ?? "rpc", model };
+    return undefined;
+}
+function stringParam(params, key) {
+    const value = params?.[key];
+    return typeof value === "string" ? value : undefined;
+}
+function numberParam(params, key) {
+    const value = params?.[key];
+    return typeof value === "number" ? value : undefined;
+}
+function objectParam(params, key) {
+    const value = params?.[key];
+    return isObject(value) ? value : undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isCommand(value) {
+    return typeof value === "string" && ["prompt", "steer", "followUp", "abort", "state", "messages", "setModel", "compact", "switchSession", "forkSession", "cloneSession", "command"].includes(value);
+}
+function readRequestId(value) {
+    return isObject(value) && (typeof value.id === "string" || typeof value.id === "number") ? value.id : null;
+}
+function write(stdout, value) {
+    stdout.write(`${JSON.stringify(value)}\n`);
+}
+//# sourceMappingURL=rpc.js.map

package/dist/security.d.ts

@@ -0,0 +1,51 @@
+import type { ErrorInfo } from "./contracts.js";
+export interface TrustRequest {
+    readonly kind: "project" | "resource" | "extension" | string;
+    readonly target: string;
+    readonly capability?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface TrustDecision {
+    readonly trusted: boolean;
+    readonly reason?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface TrustPolicy {
+    check(request: TrustRequest): TrustDecision | Promise<TrustDecision>;
+}
+export interface PermissionRequest {
+    readonly kind: "tool" | "extension" | "resource" | string;
+    readonly action: string;
+    readonly target: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface PermissionDecision {
+    readonly allowed: boolean;
+    readonly reason?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface PermissionPolicy {
+    check(request: PermissionRequest): PermissionDecision | Promise<PermissionDecision>;
+}
+export declare class TrustDeniedError extends Error {
+    readonly request: TrustRequest;
+    readonly decision: TrustDecision;
+    readonly code = "ERR_PRISM_UNTRUSTED";
+    constructor(request: TrustRequest, decision: TrustDecision);
+}
+export declare class PermissionDeniedError extends Error {
+    readonly request: PermissionRequest;
+    readonly decision: PermissionDecision;
+    readonly code = "ERR_PRISM_PERMISSION_DENIED";
+    constructor(request: PermissionRequest, decision: PermissionDecision);
+}
+export declare function isTrusted(policy: TrustPolicy | undefined, request: TrustRequest): Promise<boolean>;
+export declare function assertTrusted(policy: TrustPolicy | undefined, request: TrustRequest): Promise<void>;
+export declare function createStaticTrustPolicy(decision: boolean | TrustDecision): TrustPolicy;
+export declare function checkPermission(policy: PermissionPolicy | undefined, request: PermissionRequest): Promise<PermissionDecision>;
+export declare function assertPermission(policy: PermissionPolicy | undefined, request: PermissionRequest): Promise<void>;
+export declare function createStaticPermissionPolicy(options: {
+    readonly allow?: readonly string[];
+    readonly deny?: readonly string[];
+} | boolean): PermissionPolicy;
+export declare function denialToErrorInfo(error: unknown): ErrorInfo;

package/dist/security.js

@@ -0,0 +1,60 @@
+export class TrustDeniedError extends Error {
+    request;
+    decision;
+    code = "ERR_PRISM_UNTRUSTED";
+    constructor(request, decision) {
+        super(decision.reason ?? `Untrusted ${request.kind}: ${request.target}`);
+        this.request = request;
+        this.decision = decision;
+        this.name = "TrustDeniedError";
+    }
+}
+export class PermissionDeniedError extends Error {
+    request;
+    decision;
+    code = "ERR_PRISM_PERMISSION_DENIED";
+    constructor(request, decision) {
+        super(decision.reason ?? `Permission denied for ${request.kind}:${request.target}:${request.action}`);
+        this.request = request;
+        this.decision = decision;
+        this.name = "PermissionDeniedError";
+    }
+}
+export async function isTrusted(policy, request) {
+    return policy ? (await policy.check(request)).trusted : true;
+}
+export async function assertTrusted(policy, request) {
+    const decision = policy ? await policy.check(request) : { trusted: true };
+    if (!decision.trusted)
+        throw new TrustDeniedError(request, decision);
+}
+export function createStaticTrustPolicy(decision) {
+    const resolved = typeof decision === "boolean" ? { trusted: decision } : decision;
+    return { check: () => resolved };
+}
+export async function checkPermission(policy, request) {
+    return policy ? policy.check(request) : { allowed: true };
+}
+export async function assertPermission(policy, request) {
+    const decision = await checkPermission(policy, request);
+    if (!decision.allowed)
+        throw new PermissionDeniedError(request, decision);
+}
+export function createStaticPermissionPolicy(options) {
+    if (typeof options === "boolean")
+        return { check: () => ({ allowed: options }) };
+    const allow = new Set(options.allow ?? []);
+    const deny = new Set(options.deny ?? []);
+    return {
+        check(request) {
+            const key = `${request.kind}:${request.target}:${request.action}`;
+            if (deny.has(key))
+                return { allowed: false, reason: `Permission denied: ${key}` };
+            return { allowed: allow.size === 0 || allow.has(key), reason: allow.size && !allow.has(key) ? `Permission not allowed: ${key}` : undefined };
+        },
+    };
+}
+export function denialToErrorInfo(error) {
+    return error instanceof Error ? { name: error.name, message: error.message, code: error.code } : { message: String(error) };
+}
+//# sourceMappingURL=security.js.map

package/dist/session-stores.d.ts

@@ -0,0 +1,25 @@
+import type { Message, SessionEntry, SessionStore } from "./contracts.js";
+export interface CreateSessionEntryOptions extends Omit<SessionEntry, "id" | "timestamp"> {
+    readonly id?: string;
+    readonly timestamp?: string;
+    readonly createId?: () => string;
+    readonly now?: () => Date;
+}
+export interface SessionBranchOptions {
+    readonly leafId?: string;
+}
+export interface SessionBranch {
+    readonly leafId: string;
+    readonly entries: readonly SessionEntry[];
+}
+export interface SessionContextSnapshot {
+    readonly leafId?: string;
+    readonly entries: readonly SessionEntry[];
+    readonly messages: readonly Message[];
+    readonly summaries: readonly string[];
+}
+export declare function createSessionEntry(options: CreateSessionEntryOptions): SessionEntry;
+export declare function getSessionBranchEntries(entries: readonly SessionEntry[], options?: SessionBranchOptions): readonly SessionEntry[];
+export declare function listSessionBranches(entries: readonly SessionEntry[]): readonly SessionBranch[];
+export declare function rebuildSessionContext(entries: readonly SessionEntry[], options?: SessionBranchOptions): SessionContextSnapshot;
+export declare function createMemorySessionStore(initialEntries?: readonly SessionEntry[]): SessionStore;

package/dist/session-stores.js

@@ -0,0 +1,116 @@
+export function createSessionEntry(options) {
+    const { createId, now, ...entry } = options;
+    return {
+        ...entry,
+        id: entry.id ?? createId?.() ?? randomId("entry"),
+        timestamp: entry.timestamp ?? (now?.() ?? new Date()).toISOString(),
+    };
+}
+export function getSessionBranchEntries(entries, options = {}) {
+    const index = indexEntries(entries);
+    const leafId = options.leafId ?? entries.at(-1)?.id;
+    if (!leafId)
+        return [];
+    if (!index.byId.has(leafId))
+        throw new Error(`Unknown session leaf: ${leafId}`);
+    const branch = [];
+    for (let id = leafId; id;) {
+        const entry = index.byId.get(id);
+        if (!entry)
+            throw new Error(`Missing session parent: ${id}`);
+        branch.push(entry);
+        id = entry.parentId;
+    }
+    return branch.reverse().map(cloneEntry);
+}
+export function listSessionBranches(entries) {
+    const index = indexEntries(entries);
+    return entries
+        .filter((entry) => !index.parentIds.has(entry.id))
+        .map((entry) => ({ leafId: entry.id, entries: getSessionBranchEntries(entries, { leafId: entry.id }) }));
+}
+export function rebuildSessionContext(entries, options = {}) {
+    const branch = getSessionBranchEntries(entries, options);
+    const compaction = [...branch].reverse().find((entry) => entry.kind === "compaction" && entry.summary && isCompactionEntryData(entry.data));
+    if (!compaction || !isCompactionEntryData(compaction.data)) {
+        return {
+            leafId: branch.at(-1)?.id,
+            entries: branch,
+            messages: branch.flatMap((entry) => entry.kind === "message" && entry.message ? [entry.message] : []),
+            summaries: branch.flatMap((entry) => entry.kind === "summary" && entry.summary ? [entry.summary] : []),
+        };
+    }
+    const keepIds = new Set(compaction.data.keepEntryIds ?? []);
+    let afterThrough = !compaction.data.throughEntryId;
+    const messages = [];
+    const summaries = [compaction.summary];
+    for (const entry of branch) {
+        if (entry.id === compaction.data.throughEntryId) {
+            afterThrough = true;
+            continue;
+        }
+        if (entry.id === compaction.id)
+            continue;
+        if (entry.kind === "message" && entry.message && (afterThrough || keepIds.has(entry.id)))
+            messages.push(cloneEntry(entry.message));
+        if (entry.kind === "summary" && entry.summary && afterThrough)
+            summaries.push(entry.summary);
+    }
+    return { leafId: branch.at(-1)?.id, entries: branch, messages, summaries };
+}
+export function createMemorySessionStore(initialEntries = []) {
+    const byId = new Map();
+    const bySession = new Map();
+    for (const entry of initialEntries)
+        add(entry);
+    return {
+        async append(entry) {
+            add(entry);
+        },
+        async list(sessionId) {
+            return (bySession.get(sessionId) ?? []).map(cloneEntry);
+        },
+        async get(id) {
+            const entry = byId.get(id);
+            return entry ? cloneEntry(entry) : undefined;
+        },
+    };
+    function add(entry) {
+        if (byId.has(entry.id))
+            throw new Error(`Duplicate session entry id: ${entry.id}`);
+        byId.set(entry.id, entry);
+        const entries = bySession.get(entry.sessionId) ?? [];
+        entries.push(entry);
+        bySession.set(entry.sessionId, entries);
+    }
+}
+function cloneEntry(entry) {
+    return structuredClone(entry);
+}
+function isCompactionEntryData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const data = value;
+    return (data.throughEntryId === undefined || typeof data.throughEntryId === "string")
+        && (data.keepEntryIds === undefined || (Array.isArray(data.keepEntryIds) && data.keepEntryIds.every((item) => typeof item === "string")));
+}
+function indexEntries(entries) {
+    const byId = new Map();
+    const parentIds = new Set();
+    for (const entry of entries) {
+        if (byId.has(entry.id))
+            throw new Error(`Duplicate session entry id: ${entry.id}`);
+        byId.set(entry.id, entry);
+        if (entry.parentId)
+            parentIds.add(entry.parentId);
+    }
+    for (const parentId of parentIds) {
+        if (!byId.has(parentId))
+            throw new Error(`Missing session parent: ${parentId}`);
+    }
+    return { byId, parentIds };
+}
+function randomId(prefix) {
+    return `${prefix}_${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
+}
+//# sourceMappingURL=session-stores.js.map

package/dist/settings.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject, SettingsProvider } from "./contracts.js";
+export declare function createStaticSettingsProvider(settings: JsonObject): SettingsProvider;
+export declare function createChainedSettingsProvider(providers: readonly SettingsProvider[]): SettingsProvider;

package/dist/settings.js

@@ -0,0 +1,26 @@
+import { assertJsonObject } from "./config.js";
+export function createStaticSettingsProvider(settings) {
+    assertJsonObject(settings, "settings");
+    return {
+        get(key) {
+            return key.split(".").reduce((value, part) => {
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    return undefined;
+                return value[part];
+            }, settings);
+        },
+    };
+}
+export function createChainedSettingsProvider(providers) {
+    return {
+        async get(key) {
+            for (const provider of providers) {
+                const value = await provider.get(key);
+                if (value !== undefined)
+                    return value;
+            }
+            return undefined;
+        },
+    };
+}
+//# sourceMappingURL=settings.js.map

package/dist/skills.d.ts

@@ -0,0 +1,8 @@
+import type { Skill, SkillRegistry, ToolDefinition } from "./contracts.js";
+export interface ResolveActiveSkillsOptions {
+    readonly registry: SkillRegistry;
+    readonly names?: readonly string[];
+    readonly tools?: readonly ToolDefinition[];
+}
+export declare function createSkillRegistry(skills?: readonly Skill[]): SkillRegistry;
+export declare function resolveActiveSkills(options: ResolveActiveSkillsOptions): readonly Skill[];