@arnilo/prism 0.0.15 → 0.0.17

package/dist/contributions.d.ts

@@ -4,6 +4,8 @@ import { type ProviderRegistry } from "./providers.js";
 import { type DuplicateRegistrationOptions } from "./registry-options.js";
 export interface ContributionRegistry<T> {
     register(key: string, contribution: T): void;
+    /** Remove a contribution; returns false when the key was not registered. */
+    unregister(key: string): boolean;
     get(key: string): T | undefined;
     resolve(key: string): T;
     list(): readonly T[];

package/dist/contributions.js

@@ -9,6 +9,9 @@ export function createContributionRegistry(options = {}) {
             assertCanRegister(byKey, key, label, key, options.duplicate);
             byKey.set(key, contribution);
         },
+        unregister(key) {
+            return byKey.delete(key);
+        },
         get(key) {
             return byKey.get(key);
         },

package/dist/conversations.js

@@ -56,7 +56,8 @@ export function conversationThreadFromRecord(record) {
     const branches = [];
     if (Array.isArray(value.branches)) {
         for (const item of value.branches) {
-            if (item && typeof item === "object" &&
+            if (item &&
+                typeof item === "object" &&
                 typeof item.leafId === "string" &&
                 typeof item.createdAt === "string") {
                 branches.push({

package/dist/credentials.d.ts

@@ -1,4 +1,4 @@
-import type { Credential, CredentialResolver, CredentialRequest, CredentialResolverSource, OAuthCredentialStore, OAuthCredentials, OAuthProvider } from "./contracts.js";
+import type { Credential, CredentialRequest, CredentialResolver, CredentialResolverSource, OAuthCredentialStore, OAuthCredentials, OAuthProvider } from "./contracts.js";
 export type CredentialValueSource = string | (() => string | undefined | Promise<string | undefined>) | CredentialResolver;
 export interface CredentialRecord {
     readonly name: string;
@@ -10,7 +10,13 @@ export interface MemoryCredentialStore extends CredentialResolver {
     delete(request: Pick<CredentialRequest, "name" | "provider">): boolean;
     clear(): void;
 }
-export declare function createMemoryCredentialStore(initial?: readonly CredentialRecord[]): MemoryCredentialStore;
+export interface MemoryCredentialStoreOptions {
+    /** When true (default, backward compatible), a provider-scoped request falls back to a
+     *  providerless record of the same name — that record is then served to EVERY provider.
+     *  Set false for exact-match-only resolution (strict provider scoping). */
+    readonly allowProviderFallback?: boolean;
+}
+export declare function createMemoryCredentialStore(initial?: readonly CredentialRecord[], options?: MemoryCredentialStoreOptions): MemoryCredentialStore;
 export declare function createChainedCredentialResolver(resolvers: readonly CredentialResolver[]): CredentialResolver;
 export declare function createExplicitCredentialResolver(sources: readonly CredentialResolverSource[]): CredentialResolver;
 export declare function createEnvCredentialResolver(env: Readonly<Record<string, string | undefined>>, map: Readonly<Record<string, string>>): CredentialResolver;

package/dist/credentials.js

@@ -1,5 +1,6 @@
-export function createMemoryCredentialStore(initial = []) {
+export function createMemoryCredentialStore(initial = [], options = {}) {
     const records = new Map();
+    const allowProviderFallback = options.allowProviderFallback ?? true;
     const key = (name, provider) => `${provider ?? ""}\u0000${name}`;
     const store = {
         set(record) {
@@ -12,7 +13,10 @@ export function createMemoryCredentialStore(initial = []) {
             records.clear();
         },
         resolve(request) {
-            return records.get(key(request.name, request.provider)) ?? records.get(key(request.name));
+            const exact = records.get(key(request.name, request.provider));
+            if (exact !== undefined || !allowProviderFallback || request.provider === undefined)
+                return exact;
+            return records.get(key(request.name));
         },
     };
     for (const record of initial)
@@ -37,7 +41,9 @@ export function createExplicitCredentialResolver(sources) {
 export function createEnvCredentialResolver(env, map) {
     return {
         resolve(request) {
-            const envName = map[credentialMapKey(request.name, request.provider)] ?? (request.provider ? map[request.provider] : undefined) ?? map[request.name];
+            const envName = map[credentialMapKey(request.name, request.provider)] ??
+                (request.provider ? map[request.provider] : undefined) ??
+                map[request.name];
             const value = envName ? env[envName] : undefined;
             return value ? { type: "api_key", value, metadata: { source: "env", envName } } : undefined;
         },

package/dist/event-multiplexer.js

@@ -13,10 +13,21 @@ export function createEventMultiplexer(options = {}) {
         isClosed = true;
     else
         options.signal?.addEventListener("abort", abort, { once: true });
+    // With compare set, publish always enqueues and the parked consumer is woken with
+    // this token instead of a value, so every event drains through the sorted queue —
+    // delivery order follows the comparator even when the consumer is caught up.
+    const WAKE = Symbol("wake");
+    const wakeWaiter = () => {
+        if (!waiter)
+            return;
+        const resolve = waiter;
+        waiter = undefined;
+        resolve({ value: WAKE, done: false });
+    };
     function publish(event) {
         if (isClosed)
             return;
-        if (waiter) {
+        if (!options.compare && waiter) {
             const resolve = waiter;
             waiter = undefined;
             resolve({ value: event, done: false });
@@ -24,12 +35,11 @@ export function createEventMultiplexer(options = {}) {
         }
         if (queue.length < maxQueuedEvents) {
             queue.push(event);
+            wakeWaiter();
             return;
         }
         droppedEvents += 1;
-        const notice = !overflowNotified && options.overflowEvent
-            ? options.overflowEvent({ droppedEvents, maxQueuedEvents, policy: overflow })
-            : undefined;
+        const notice = !overflowNotified && options.overflowEvent ? options.overflowEvent({ droppedEvents, maxQueuedEvents, policy: overflow }) : undefined;
         overflowNotified = true;
         if (overflow === "close") {
             queue.length = 0;
@@ -43,6 +53,7 @@ export function createEventMultiplexer(options = {}) {
         if (overflow === "drop_newest") {
             if (notice !== undefined)
                 queue[queue.length - 1] = notice;
+            wakeWaiter();
             return;
         }
         queue.shift();
@@ -52,6 +63,7 @@ export function createEventMultiplexer(options = {}) {
                 queue.shift();
         }
         queue.push(event);
+        wakeWaiter();
     }
     function observe(source, map) {
         if (isClosed)
@@ -117,6 +129,8 @@ export function createEventMultiplexer(options = {}) {
             });
             if (next.done)
                 return;
+            if (next.value === WAKE)
+                continue;
             yield next.value;
         }
     }

package/dist/extensions.d.ts

@@ -26,11 +26,17 @@ export interface ExtensionEventBus {
     on(type: ExtensionLifecycleEventName | string, handler: ExtensionEventHandler): () => void;
     emit(event: ExtensionEvent): Promise<void>;
 }
+export interface LoadedExtension {
+    readonly name: string;
+    /** Remove this extension's registry contributions and middleware/event subscriptions.
+     *  Best-effort and idempotent; side effects outside the registries are NOT unwound. */
+    dispose(): void;
+}
 export interface ExtensionKernel {
     readonly registries: ContributionRegistries;
     readonly middleware: MiddlewareRegistry;
     readonly events: ExtensionEventBus;
-    load(extensions: readonly Extension[]): Promise<void>;
+    load(extensions: readonly Extension[]): Promise<LoadedExtension[]>;
 }
 export declare function createExtensionEventBus(options?: Pick<ExtensionKernelOptions, "errorPolicy" | "secrets">): ExtensionEventBus;
 export declare function createExtensionKernel(options?: ExtensionKernelOptions): ExtensionKernel;

package/dist/extensions.js

@@ -45,90 +45,148 @@ export function createExtensionKernel(options = {}) {
     const middleware = options.middleware ?? createMiddlewareRegistry({ ...options, onError: events.emit });
     const errorPolicy = options.errorPolicy ?? "event";
     const secrets = options.secrets ?? [];
-    const api = {
+    // Per-extension tracked API: every registration records an undo so a dispose handle
+    // (or a failed setup) can unwind exactly what that extension added.
+    const createApi = (track) => ({
         registries,
         middleware,
-        on: events.on,
+        on(type, handler) {
+            const off = events.on(type, handler);
+            track?.(off);
+            return off;
+        },
         emit: events.emit,
-        use: middleware.use,
+        use(hook, mw) {
+            const off = middleware.use(hook, mw);
+            track?.(off);
+            return off;
+        },
         registerProvider(provider) {
             registries.providers.register(provider);
+            track?.(() => registries.providers.unregister(provider.id));
         },
         registerModel(model) {
             registries.models.register(model);
+            track?.(() => registries.models.unregister(model.provider, model.model));
         },
         registerTool(tool) {
             registries.tools.register(tool.name, tool);
+            track?.(() => registries.tools.unregister(tool.name));
         },
         registerContextProvider(provider) {
             registries.contextProviders.register(provider.name, provider);
+            track?.(() => registries.contextProviders.unregister(provider.name));
         },
         registerSkill(skill) {
             registries.skills.register(skill.name, skill);
+            track?.(() => registries.skills.unregister(skill.name));
         },
         registerCommand(command) {
             registries.commands.register(command.name, command);
+            track?.(() => registries.commands.unregister(command.name));
         },
         registerAgent(agent) {
             registries.agents.register(agent.name, agent);
+            track?.(() => registries.agents.unregister(agent.name));
         },
         registerInputBuilder(builder) {
             registries.inputBuilders.register(builder.name, builder);
+            track?.(() => registries.inputBuilders.unregister(builder.name));
         },
         registerPromptBuilder(builder) {
             registries.promptBuilders.register(builder.name, builder);
+            track?.(() => registries.promptBuilders.unregister(builder.name));
         },
         registerCompactionStrategy(strategy) {
             registries.compactionStrategies.register(strategy.name, strategy);
+            track?.(() => registries.compactionStrategies.unregister(strategy.name));
         },
         registerRetryPolicy(policy) {
             registries.retryPolicies.register(policy.name, policy);
+            track?.(() => registries.retryPolicies.unregister(policy.name));
         },
         registerStoreFactory(factory) {
             registries.storeFactories.register(factory.name, factory);
+            track?.(() => registries.storeFactories.unregister(factory.name));
         },
         registerResourceLoader(key, loader) {
             registries.resourceLoaders.register(key, loader);
+            track?.(() => registries.resourceLoaders.unregister(key));
         },
         registerSettingsProvider(key, provider) {
             registries.settingsProviders.register(key, provider);
+            track?.(() => registries.settingsProviders.unregister(key));
         },
         registerCredentialResolver(key, resolver) {
             registries.credentialResolvers.register(key, resolver);
+            track?.(() => registries.credentialResolvers.unregister(key));
         },
         registerProviderPackage(providerPackage) {
             registries.providerPackages.register(providerPackage.name, providerPackage);
+            track?.(() => registries.providerPackages.unregister(providerPackage.name));
         },
         registerAuthMethod(method) {
-            registries.authMethods.register(authMethodKey(method), method);
+            const key = authMethodKey(method);
+            registries.authMethods.register(key, method);
+            track?.(() => registries.authMethods.unregister(key));
         },
         registerProviderRequestPolicy(policy) {
             registries.providerRequestPolicies.register(policy.name, policy);
+            track?.(() => registries.providerRequestPolicies.unregister(policy.name));
         },
         registerSystemPromptContribution(contribution) {
-            registries.systemPromptContributions.register(systemPromptContributionKey(contribution), contribution);
+            const key = systemPromptContributionKey(contribution);
+            registries.systemPromptContributions.register(key, contribution);
+            track?.(() => registries.systemPromptContributions.unregister(key));
         },
         registerInstructionInjector(injector) {
             registries.instructionInjectors.register(injector.name, injector);
+            track?.(() => registries.instructionInjectors.unregister(injector.name));
         },
+    });
+    const unwind = (undo) => {
+        for (const fn of undo.reverse()) {
+            try {
+                fn();
+            }
+            catch {
+                // best-effort: one stuck undo must not block the rest
+            }
+        }
     };
     return {
         registries,
         middleware,
         events,
         async load(extensions) {
+            const loaded = [];
             for (const extension of extensions) {
+                const undo = [];
                 try {
                     await assertPermission(options.permission, { kind: "extension", action: "setup", target: extension.name });
                     await assertExtensionLoadPolicy(options.loadPolicy, extension);
-                    await extension.setup(api);
+                    await extension.setup(createApi((fn) => undo.push(fn)));
                 }
                 catch (error) {
+                    // A failed setup must not leave partial contributions behind.
+                    unwind(undo);
                     if (errorPolicy === "throw")
                         throw error;
                     await events.emit(extensionError(error, extension.name, secrets));
+                    continue;
                 }
+                let disposed = false;
+                loaded.push({
+                    name: extension.name,
+                    dispose() {
+                        if (disposed)
+                            return;
+                        disposed = true;
+                        unwind(undo);
+                    },
+                });
             }
+            return loaded;
         },
     };
 }

package/dist/feedback.js

@@ -48,10 +48,14 @@ export async function prepareRunFeedback(input, options) {
     const tags = normalizeList(input.tags, maxTags, MAX_FEEDBACK_TAG_LENGTH, "tag");
     const scorerIds = normalizeList(input.scorerIds, maxLinks, MAX_FEEDBACK_ID_LENGTH, "scorer id", true);
     const evaluationIds = normalizeList(input.evaluationIds, maxLinks, MAX_FEEDBACK_ID_LENGTH, "evaluation id", true);
-    if (input.rating === undefined && input.comment === undefined && tags.length === 0 && scorerIds.length === 0 && evaluationIds.length === 0) {
+    if (input.rating === undefined &&
+        input.comment === undefined &&
+        tags.length === 0 &&
+        scorerIds.length === 0 &&
+        evaluationIds.length === 0) {
         throw new RunFeedbackError("feedback requires rating, comment, tag, scorer, or evaluation", "ERR_PRISM_RUN_FEEDBACK_EMPTY");
     }
-    const redact = (value) => options.redactor ? options.redactor.redact(value) : value;
+    const redact = (value) => (options.redactor ? options.redactor.redact(value) : value);
     const comment = input.comment === undefined ? undefined : redact(input.comment);
     const safeTags = Object.freeze(normalizeList(redact(tags), maxTags, MAX_FEEDBACK_TAG_LENGTH, "tag"));
     const metadata = input.metadata === undefined ? undefined : redact(input.metadata);
@@ -121,18 +125,16 @@ export function runFeedbackPageLimit(limit, maximum = HARD_FEEDBACK_PAGE_SIZE) {
     return pageLimit(limit, maximum);
 }
 function requireOwnership(input) {
-    if (!input.tenantId?.trim()
-        || (input.accountId !== undefined && !input.accountId.trim())
-        || (input.userId !== undefined && !input.userId.trim())
-        || (!input.accountId && !input.userId)) {
+    if (!input.tenantId?.trim() ||
+        (input.accountId !== undefined && !input.accountId.trim()) ||
+        (input.userId !== undefined && !input.userId.trim()) ||
+        (!input.accountId && !input.userId)) {
         throw new RunFeedbackError("tenantId and non-empty accountId or userId are required", "ERR_PRISM_RUN_FEEDBACK_OWNERSHIP");
     }
     return { tenantId: input.tenantId, accountId: input.accountId, userId: input.userId };
 }
 function sameOwnership(expected, actual) {
-    return expected.tenantId === actual.tenantId
-        && expected.accountId === actual.accountId
-        && expected.userId === actual.userId;
+    return expected.tenantId === actual.tenantId && expected.accountId === actual.accountId && expected.userId === actual.userId;
 }
 function requireId(value, label) {
     if (!value || value.length > MAX_FEEDBACK_ID_LENGTH || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value)) {
@@ -214,7 +216,7 @@ function freezeRecord(record) {
     });
 }
 function cloneFrozenJsonObject(value) {
-    const cloned = JSON.parse(JSON.stringify(value));
+    const cloned = structuredClone(value);
     if (!cloned || typeof cloned !== "object" || Array.isArray(cloned))
         throw new RunFeedbackError("metadata must be a JSON object");
     return deepFreeze(cloned);

package/dist/guardrails.d.ts

@@ -1,4 +1,4 @@
-import type { AgentEvent, GuardrailContext, GuardrailRecord, Guardrails, GuardrailStage, GuardrailValue } from "./contracts.js";
+import type { AgentEvent, GuardrailContext, GuardrailRecord, GuardrailStage, Guardrails, GuardrailValue } from "./contracts.js";
 import type { SecretRedactor } from "./redaction.js";
 export declare const MAX_GUARDRAIL_CONCURRENCY = 16;
 export declare class GuardrailError extends Error {

package/dist/guardrails.js

@@ -5,11 +5,11 @@ export class GuardrailError extends Error {
     code;
     record;
     constructor(record) {
-        super(record.action === "interrupt" ? "Guardrail interruption is unavailable" : "Guardrail blocked run");
+        super(record.action === "interrupt"
+            ? `Guardrail interruption is unavailable at stage "${record.stage}"; interrupt suspends only at the input stage of durable runs`
+            : "Guardrail blocked run");
         this.name = "GuardrailError";
-        this.code = record.action === "interrupt"
-            ? "ERR_PRISM_GUARDRAIL_INTERRUPT_UNAVAILABLE"
-            : "ERR_PRISM_GUARDRAIL_BLOCKED";
+        this.code = record.action === "interrupt" ? "ERR_PRISM_GUARDRAIL_INTERRUPT_UNAVAILABLE" : "ERR_PRISM_GUARDRAIL_BLOCKED";
         this.record = record;
     }
 }
@@ -20,9 +20,7 @@ export async function runGuardrails(options) {
         return { records: [] };
     const maxConcurrency = resolveConcurrency(options.guardrails?.maxConcurrency);
     const controller = new AbortController();
-    const signal = options.context.signal
-        ? AbortSignal.any([options.context.signal, controller.signal])
-        : controller.signal;
+    const signal = options.context.signal ? AbortSignal.any([options.context.signal, controller.signal]) : controller.signal;
     const records = new Array(guards.length);
     let next = 0;
     let stopped = false;
@@ -66,14 +64,23 @@ function stageGuards(guardrails, stage) {
     if (!guardrails)
         return [];
     switch (stage) {
-        case "input": return (guardrails.input ?? []);
-        case "output": return (guardrails.output ?? []);
-        case "tool_input": return (guardrails.toolInput ?? []);
-        case "tool_output": return (guardrails.toolOutput ?? []);
+        case "input":
+            return (guardrails.input ?? []);
+        case "output":
+            return (guardrails.output ?? []);
+        case "tool_input":
+            return (guardrails.toolInput ?? []);
+        case "tool_output":
+            return (guardrails.toolOutput ?? []);
     }
 }
 async function evaluate(guardrail, options, signal) {
-    if (!guardrail || typeof guardrail.name !== "string" || !guardrail.name || guardrail.name.length > 128 || guardrail.stage !== options.stage || typeof guardrail.evaluate !== "function") {
+    if (!guardrail ||
+        typeof guardrail.name !== "string" ||
+        !guardrail.name ||
+        guardrail.name.length > 128 ||
+        guardrail.stage !== options.stage ||
+        typeof guardrail.evaluate !== "function") {
         return record(guardrail?.name ?? "invalid", options.stage, "tripwire", "guardrail_invalid", undefined, options.redactor);
     }
     try {
@@ -83,8 +90,12 @@ async function evaluate(guardrail, options, signal) {
         }
         return record(guardrail.name, options.stage, decision.action, decision.reason, decision.metadata, options.redactor);
     }
-    catch {
-        return record(guardrail.name, options.stage, "tripwire", "guardrail_failed", undefined, options.redactor);
+    catch (error) {
+        // Keep the cause diagnosable without leaking internals: message only, bounded and
+        // passed through the same redact+bound metadata path as guardrail-provided metadata.
+        const message = error instanceof Error ? error.message : String(error);
+        const redacted = options.redactor?.redact(message) ?? message;
+        return record(guardrail.name, options.stage, "tripwire", "guardrail_failed", { error: boundText(redacted, MAX_REASON_BYTES) }, options.redactor);
     }
 }
 function resolveConcurrency(value) {
@@ -115,9 +126,7 @@ function boundedMetadata(value, redactor) {
         if (!json || byteLength(json) > MAX_METADATA_BYTES)
             return { truncated: true };
         const parsed = JSON.parse(json);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : undefined;
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
     }
     catch {
         return { invalid: true };

package/dist/identity.js

@@ -104,9 +104,17 @@ export function narrowIdentity(parent, options) {
         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 } : {}),
+        ...(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 } : {}),
+        ...(options.metadata !== undefined
+            ? { metadata: options.metadata }
+            : parent.metadata !== undefined
+                ? { metadata: parent.metadata }
+                : {}),
         verified: true,
     };
     assertIdentityActive(child, { limits: options.limits });