@arnilo/prism 0.0.1

package/dist/contributions.d.ts

@@ -0,0 +1,35 @@
+import type { AgentDefinition, AuthMethod, CommandDefinition, CompactionStrategy, ContextProvider, CredentialResolver, InputBuilder, PromptBuilder, ProviderPackage, ProviderRequestPolicy, ResourceLoader, RetryPolicy, SettingsProvider, Skill, StoreFactory, SystemPromptContribution, ToolDefinition } from "./contracts.js";
+import { type ModelRegistry } from "./models.js";
+import { type ProviderRegistry } from "./providers.js";
+export interface ContributionRegistry<T> {
+    register(key: string, contribution: T): void;
+    get(key: string): T | undefined;
+    resolve(key: string): T;
+    list(): readonly T[];
+}
+export interface ContributionRegistryOptions {
+    readonly label?: string;
+}
+export declare function createContributionRegistry<T>(options?: ContributionRegistryOptions): ContributionRegistry<T>;
+export interface ContributionRegistries {
+    readonly providers: ProviderRegistry;
+    readonly models: ModelRegistry;
+    readonly tools: ContributionRegistry<ToolDefinition>;
+    readonly contextProviders: ContributionRegistry<ContextProvider>;
+    readonly skills: ContributionRegistry<Skill>;
+    readonly commands: ContributionRegistry<CommandDefinition>;
+    readonly agents: ContributionRegistry<AgentDefinition>;
+    readonly inputBuilders: ContributionRegistry<InputBuilder>;
+    readonly promptBuilders: ContributionRegistry<PromptBuilder>;
+    readonly compactionStrategies: ContributionRegistry<CompactionStrategy>;
+    readonly retryPolicies: ContributionRegistry<RetryPolicy>;
+    readonly storeFactories: ContributionRegistry<StoreFactory>;
+    readonly resourceLoaders: ContributionRegistry<ResourceLoader>;
+    readonly settingsProviders: ContributionRegistry<SettingsProvider>;
+    readonly credentialResolvers: ContributionRegistry<CredentialResolver>;
+    readonly providerPackages: ContributionRegistry<ProviderPackage>;
+    readonly authMethods: ContributionRegistry<AuthMethod>;
+    readonly providerRequestPolicies: ContributionRegistry<ProviderRequestPolicy>;
+    readonly systemPromptContributions: ContributionRegistry<SystemPromptContribution>;
+}
+export declare function createContributionRegistries(): ContributionRegistries;

package/dist/contributions.js

@@ -0,0 +1,47 @@
+import { createModelRegistry } from "./models.js";
+import { createProviderRegistry } from "./providers.js";
+export function createContributionRegistry(options = {}) {
+    const label = options.label ?? "contribution";
+    const byKey = new Map();
+    return {
+        register(key, contribution) {
+            byKey.set(key, contribution);
+        },
+        get(key) {
+            return byKey.get(key);
+        },
+        resolve(key) {
+            const contribution = byKey.get(key);
+            if (!contribution)
+                throw new Error(`Unknown ${label}: ${key}`);
+            return contribution;
+        },
+        list() {
+            return [...byKey.values()];
+        },
+    };
+}
+export function createContributionRegistries() {
+    return {
+        providers: createProviderRegistry(),
+        models: createModelRegistry(),
+        tools: createContributionRegistry({ label: "tool" }),
+        contextProviders: createContributionRegistry({ label: "context provider" }),
+        skills: createContributionRegistry({ label: "skill" }),
+        commands: createContributionRegistry({ label: "command" }),
+        agents: createContributionRegistry({ label: "agent" }),
+        inputBuilders: createContributionRegistry({ label: "input builder" }),
+        promptBuilders: createContributionRegistry({ label: "prompt builder" }),
+        compactionStrategies: createContributionRegistry({ label: "compaction strategy" }),
+        retryPolicies: createContributionRegistry({ label: "retry policy" }),
+        storeFactories: createContributionRegistry({ label: "store factory" }),
+        resourceLoaders: createContributionRegistry({ label: "resource loader" }),
+        settingsProviders: createContributionRegistry({ label: "settings provider" }),
+        credentialResolvers: createContributionRegistry({ label: "credential resolver" }),
+        providerPackages: createContributionRegistry({ label: "provider package" }),
+        authMethods: createContributionRegistry({ label: "auth method" }),
+        providerRequestPolicies: createContributionRegistry({ label: "provider request policy" }),
+        systemPromptContributions: createContributionRegistry({ label: "system prompt contribution" }),
+    };
+}
+//# sourceMappingURL=contributions.js.map

package/dist/credentials.d.ts

@@ -0,0 +1,22 @@
+import type { Credential, CredentialResolver, CredentialRequest, CredentialResolverSource, OAuthCredentialStore, OAuthCredentials, OAuthProvider } from "./contracts.js";
+export type CredentialValueSource = string | (() => string | undefined | Promise<string | undefined>) | CredentialResolver;
+export interface CredentialRecord {
+    readonly name: string;
+    readonly provider?: string;
+    readonly credential: Credential;
+}
+export interface MemoryCredentialStore extends CredentialResolver {
+    set(record: CredentialRecord): void;
+    delete(request: Pick<CredentialRequest, "name" | "provider">): boolean;
+    clear(): void;
+}
+export declare function createMemoryCredentialStore(initial?: readonly CredentialRecord[]): 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;
+export declare function refreshOAuthCredential(options: {
+    readonly provider: OAuthProvider;
+    readonly credentials: OAuthCredentials;
+    readonly store?: OAuthCredentialStore;
+}): Promise<OAuthCredentials>;
+export declare function resolveCredentialValue(source: CredentialValueSource | undefined, request: CredentialRequest): Promise<string | undefined>;

package/dist/credentials.js

@@ -0,0 +1,63 @@
+export function createMemoryCredentialStore(initial = []) {
+    const records = new Map();
+    const key = (name, provider) => `${provider ?? ""}\u0000${name}`;
+    const store = {
+        set(record) {
+            records.set(key(record.name, record.provider), record.credential);
+        },
+        delete(request) {
+            return records.delete(key(request.name, request.provider));
+        },
+        clear() {
+            records.clear();
+        },
+        resolve(request) {
+            return records.get(key(request.name, request.provider)) ?? records.get(key(request.name));
+        },
+    };
+    for (const record of initial)
+        store.set(record);
+    return store;
+}
+export function createChainedCredentialResolver(resolvers) {
+    return createExplicitCredentialResolver(resolvers.map((resolver, index) => ({ name: String(index), resolver })));
+}
+export function createExplicitCredentialResolver(sources) {
+    return {
+        async resolve(request) {
+            for (const source of sources) {
+                const credential = await source.resolver.resolve(request);
+                if (credential)
+                    return credential;
+            }
+            return undefined;
+        },
+    };
+}
+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 value = envName ? env[envName] : undefined;
+            return value ? { type: "api_key", value, metadata: { source: "env", envName } } : undefined;
+        },
+    };
+}
+export async function refreshOAuthCredential(options) {
+    const refreshed = options.provider.refresh ? await options.provider.refresh(options.credentials) : options.credentials;
+    await options.store?.set(options.provider.id, refreshed);
+    return refreshed;
+}
+function credentialMapKey(name, provider) {
+    return provider ? `${provider}:${name}` : name;
+}
+export async function resolveCredentialValue(source, request) {
+    if (!source)
+        return undefined;
+    if (typeof source === "string")
+        return source;
+    if (typeof source === "function")
+        return source();
+    return (await source.resolve(request))?.value;
+}
+//# sourceMappingURL=credentials.js.map

package/dist/extensions.d.ts

@@ -0,0 +1,25 @@
+import type { Extension, ExtensionEvent, ExtensionLifecycleEventName } from "./contracts.js";
+import { type ContributionRegistries } from "./contributions.js";
+import { type MiddlewareRegistry } from "./middleware.js";
+import { type PermissionPolicy } from "./security.js";
+export type ExtensionEventHandler = (event: ExtensionEvent) => void | Promise<void>;
+export type ExtensionErrorPolicy = "event" | "throw";
+export interface ExtensionKernelOptions {
+    readonly registries?: ContributionRegistries;
+    readonly middleware?: MiddlewareRegistry;
+    readonly errorPolicy?: ExtensionErrorPolicy;
+    readonly secrets?: readonly (string | undefined)[];
+    readonly permission?: PermissionPolicy;
+}
+export interface ExtensionEventBus {
+    on(type: ExtensionLifecycleEventName | string, handler: ExtensionEventHandler): () => void;
+    emit(event: ExtensionEvent): Promise<void>;
+}
+export interface ExtensionKernel {
+    readonly registries: ContributionRegistries;
+    readonly middleware: MiddlewareRegistry;
+    readonly events: ExtensionEventBus;
+    load(extensions: readonly Extension[]): Promise<void>;
+}
+export declare function createExtensionEventBus(options?: Pick<ExtensionKernelOptions, "errorPolicy" | "secrets">): ExtensionEventBus;
+export declare function createExtensionKernel(options?: ExtensionKernelOptions): ExtensionKernel;

package/dist/extensions.js

@@ -0,0 +1,131 @@
+import { createContributionRegistries } from "./contributions.js";
+import { createMiddlewareRegistry } from "./middleware.js";
+import { authMethodKey, systemPromptContributionKey } from "./provider-packages.js";
+import { errorToErrorInfo } from "./redaction.js";
+import { assertPermission } from "./security.js";
+function extensionError(error, source, secrets = []) {
+    return { type: "extension_error", extension: source, error: errorToErrorInfo(error, secrets) };
+}
+export function createExtensionEventBus(options = {}) {
+    const handlers = new Map();
+    const errorPolicy = options.errorPolicy ?? "event";
+    const secrets = options.secrets ?? [];
+    const bus = {
+        on(type, handler) {
+            const list = handlers.get(type) ?? [];
+            list.push(handler);
+            handlers.set(type, list);
+            return () => {
+                const next = (handlers.get(type) ?? []).filter((item) => item !== handler);
+                if (next.length === 0)
+                    handlers.delete(type);
+                else
+                    handlers.set(type, next);
+            };
+        },
+        async emit(event) {
+            for (const handler of handlers.get(event.type) ?? []) {
+                try {
+                    await handler(event);
+                }
+                catch (error) {
+                    if (errorPolicy === "throw")
+                        throw error;
+                    if (event.type !== "extension_error")
+                        await bus.emit(extensionError(error, event.extension, secrets));
+                }
+            }
+        },
+    };
+    return bus;
+}
+export function createExtensionKernel(options = {}) {
+    const registries = options.registries ?? createContributionRegistries();
+    const events = createExtensionEventBus(options);
+    const middleware = options.middleware ?? createMiddlewareRegistry({ ...options, onError: events.emit });
+    const errorPolicy = options.errorPolicy ?? "event";
+    const secrets = options.secrets ?? [];
+    const api = {
+        registries,
+        middleware,
+        on: events.on,
+        emit: events.emit,
+        use: middleware.use,
+        registerProvider(provider) {
+            registries.providers.register(provider);
+        },
+        registerModel(model) {
+            registries.models.register(model);
+        },
+        registerTool(tool) {
+            registries.tools.register(tool.name, tool);
+        },
+        registerContextProvider(provider) {
+            registries.contextProviders.register(provider.name, provider);
+        },
+        registerSkill(skill) {
+            registries.skills.register(skill.name, skill);
+        },
+        registerCommand(command) {
+            registries.commands.register(command.name, command);
+        },
+        registerAgent(agent) {
+            registries.agents.register(agent.name, agent);
+        },
+        registerInputBuilder(builder) {
+            registries.inputBuilders.register(builder.name, builder);
+        },
+        registerPromptBuilder(builder) {
+            registries.promptBuilders.register(builder.name, builder);
+        },
+        registerCompactionStrategy(strategy) {
+            registries.compactionStrategies.register(strategy.name, strategy);
+        },
+        registerRetryPolicy(policy) {
+            registries.retryPolicies.register(policy.name, policy);
+        },
+        registerStoreFactory(factory) {
+            registries.storeFactories.register(factory.name, factory);
+        },
+        registerResourceLoader(key, loader) {
+            registries.resourceLoaders.register(key, loader);
+        },
+        registerSettingsProvider(key, provider) {
+            registries.settingsProviders.register(key, provider);
+        },
+        registerCredentialResolver(key, resolver) {
+            registries.credentialResolvers.register(key, resolver);
+        },
+        registerProviderPackage(providerPackage) {
+            registries.providerPackages.register(providerPackage.name, providerPackage);
+        },
+        registerAuthMethod(method) {
+            registries.authMethods.register(authMethodKey(method), method);
+        },
+        registerProviderRequestPolicy(policy) {
+            registries.providerRequestPolicies.register(policy.name, policy);
+        },
+        registerSystemPromptContribution(contribution) {
+            registries.systemPromptContributions.register(systemPromptContributionKey(contribution), contribution);
+        },
+    };
+    return {
+        registries,
+        middleware,
+        events,
+        async load(extensions) {
+            for (const extension of extensions) {
+                try {
+                    await assertPermission(options.permission, { kind: "extension", action: "setup", target: extension.name });
+                    await extension.setup(api);
+                }
+                catch (error) {
+                    if (errorPolicy === "throw")
+                        throw error;
+                    await events.emit(extensionError(error, extension.name, secrets));
+                }
+            }
+        },
+    };
+}
+//# sourceMappingURL=extensions.js.map

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+export type * from "./contracts.js";
+export { createAgent, createAgentSession } from "./agents.js";
+export { assertJsonObject, isJsonObject, loadConfigLayers, mergeConfigLayers } from "./config.js";
+export type { ConfigLayer, ConfigLoadContext, ConfigProvider } from "./config.js";
+export { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
+export type { DefaultCompactionStrategyOptions } from "./compaction.js";
+export { createDefaultRetryPolicy, isTransientErrorInfo, waitForRetry } from "./retry.js";
+export type { DefaultRetryPolicyOptions } from "./retry.js";
+export { createContributionRegistries, createContributionRegistry } from "./contributions.js";
+export type { ContributionRegistries, ContributionRegistry, ContributionRegistryOptions } from "./contributions.js";
+export { createChainedCredentialResolver, createEnvCredentialResolver, createExplicitCredentialResolver, createMemoryCredentialStore, refreshOAuthCredential, resolveCredentialValue } from "./credentials.js";
+export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
+export type { ExtensionErrorPolicy, ExtensionEventBus, ExtensionEventHandler, ExtensionKernel, ExtensionKernelOptions } from "./extensions.js";
+export type { CredentialRecord, CredentialValueSource, MemoryCredentialStore } from "./credentials.js";
+export { createModelRegistry } from "./models.js";
+export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
+export { createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions } from "./provider-request-policy.js";
+export type { SessionCachePolicyOptions } from "./provider-request-policy.js";
+export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
+export type { ComposeSystemPromptOptions } from "./system-prompts.js";
+export type { ModelRegistry } from "./models.js";
+export { definePrismManifest, parsePrismManifest } from "./manifests.js";
+export type { ManifestContributionDeclaration, ManifestContributionKind, ManifestResourceDeclaration, PrismManifest } from "./manifests.js";
+export { loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
+export { createChainedSettingsProvider, createStaticSettingsProvider } from "./settings.js";
+export { createMiddlewareRegistry } from "./middleware.js";
+export type { Middleware, MiddlewareHookName, MiddlewareNext, MiddlewareRegistry, MiddlewareRegistryOptions } from "./middleware.js";
+export { assembleProviderInput, createDefaultInputBuilder, createDefaultPromptBuilder, renderPromptTemplate, resolveContextProviders } from "./input.js";
+export type { AgentInput, AssembleProviderInputOptions, DefaultInputBuilder, DefaultInputBuildContext, DefaultPromptBuilder, InputAttachment, PromptInstruction, PromptTemplateOptions, ResolveContextOptions } from "./input.js";
+export { createMockProvider } from "./mock-provider.js";
+export { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, listSessionBranches, rebuildSessionContext } from "./session-stores.js";
+export type { CreateSessionEntryOptions, SessionBranch, SessionBranchOptions, SessionContextSnapshot } from "./session-stores.js";
+export type { MockProviderOptions } from "./mock-provider.js";
+export { providerContentDelta, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "./provider-events.js";
+export { createProviderRegistry } from "./providers.js";
+export type { ProviderRegistry } from "./providers.js";
+export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+export type { SecretRedactor } from "./redaction.js";
+export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
+export type { PermissionDecision, PermissionPolicy, PermissionRequest, TrustDecision, TrustPolicy, TrustRequest } from "./security.js";
+export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
+export type { ResolveActiveSkillsOptions } from "./skills.js";
+export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
+export type { DispatchToolCallOptions, ToolFilter, ToolFilterInput, ToolValidator } from "./tools.js";
+export declare const name = "prism";
+export declare const version = "0.0.1";
+export declare const description = "Agent harness for AI providers, agents, sessions, and tools.";

package/dist/index.js

@@ -0,0 +1,28 @@
+export { createAgent, createAgentSession } from "./agents.js";
+export { assertJsonObject, isJsonObject, loadConfigLayers, mergeConfigLayers } from "./config.js";
+export { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
+export { createDefaultRetryPolicy, isTransientErrorInfo, waitForRetry } from "./retry.js";
+export { createContributionRegistries, createContributionRegistry } from "./contributions.js";
+export { createChainedCredentialResolver, createEnvCredentialResolver, createExplicitCredentialResolver, createMemoryCredentialStore, refreshOAuthCredential, resolveCredentialValue } from "./credentials.js";
+export { createExtensionEventBus, createExtensionKernel } from "./extensions.js";
+export { createModelRegistry } from "./models.js";
+export { authMethodKey, defineProviderPackage, systemPromptContributionKey } from "./provider-packages.js";
+export { createProviderRequestPolicyChain, createSessionCachePolicy, mergeProviderRequestOptions } from "./provider-request-policy.js";
+export { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
+export { definePrismManifest, parsePrismManifest } from "./manifests.js";
+export { loadJsonResource, loadManifestResource, loadTextResource } from "./resources.js";
+export { createChainedSettingsProvider, createStaticSettingsProvider } from "./settings.js";
+export { createMiddlewareRegistry } from "./middleware.js";
+export { assembleProviderInput, createDefaultInputBuilder, createDefaultPromptBuilder, renderPromptTemplate, resolveContextProviders } from "./input.js";
+export { createMockProvider } from "./mock-provider.js";
+export { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, listSessionBranches, rebuildSessionContext } from "./session-stores.js";
+export { providerContentDelta, providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "./provider-events.js";
+export { createProviderRegistry } from "./providers.js";
+export { createSecretRedactor, errorToErrorInfo, redactAgentEvent, redactMessage, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+export { assertPermission, assertTrusted, checkPermission, createStaticPermissionPolicy, createStaticTrustPolicy, denialToErrorInfo, isTrusted, PermissionDeniedError, TrustDeniedError } from "./security.js";
+export { createSkillRegistry, resolveActiveSkills } from "./skills.js";
+export { createToolRegistry, dispatchToolCall, filterTools } from "./tools.js";
+export const name = "prism";
+export const version = "0.0.1";
+export const description = "Agent harness for AI providers, agents, sessions, and tools.";
+//# sourceMappingURL=index.js.map

package/dist/input.d.ts

@@ -0,0 +1,57 @@
+import type { ContentBlock, ContextBlock, ContextProvider, ContextResolutionContext, InputBuilder, InputBuildContext, JsonObject, Message, ModelConfig, PromptBuilder, PromptBuildRequest, ProviderRequest, ProviderRequestOptions, ResourceLoader, Skill, ToolDefinition, ToolResult } from "./contracts.js";
+import type { MiddlewareRegistry } from "./middleware.js";
+export type AgentInput = string | Message | readonly Message[];
+export interface PromptInstruction {
+    readonly text: string;
+    readonly label?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface InputAttachment {
+    readonly name?: string;
+    readonly text?: string;
+    readonly content?: readonly ContentBlock[];
+    readonly uri?: string;
+    readonly mediaType?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export interface DefaultInputBuildContext extends InputBuildContext {
+    readonly systemInstructions?: string | readonly string[];
+    readonly developerInstructions?: string | readonly string[];
+    readonly instructions?: string | PromptInstruction | readonly PromptInstruction[];
+    readonly history?: readonly Message[];
+    readonly summaries?: readonly (string | ContextBlock)[];
+    readonly attachments?: readonly InputAttachment[];
+    readonly resourceUris?: readonly string[];
+    readonly resourceLoader?: ResourceLoader;
+    readonly toolResults?: readonly ToolResult[];
+    readonly middleware?: MiddlewareRegistry;
+}
+export interface DefaultInputBuilder extends InputBuilder {
+    build(input: AgentInput, context?: DefaultInputBuildContext): Promise<readonly Message[]>;
+}
+export interface ResolveContextOptions extends Omit<ContextResolutionContext, "messages"> {
+    readonly messages: readonly Message[];
+    readonly providers?: readonly ContextProvider[];
+    readonly middleware?: MiddlewareRegistry;
+}
+export interface DefaultPromptBuilder extends PromptBuilder {
+    build(request: PromptBuildRequest): Promise<readonly Message[]>;
+}
+export interface PromptTemplateOptions {
+    readonly missing?: "throw" | "preserve";
+}
+export interface AssembleProviderInputOptions extends DefaultInputBuildContext {
+    readonly model: ModelConfig;
+    readonly input: AgentInput;
+    readonly inputBuilder?: InputBuilder;
+    readonly contextProviders?: readonly ContextProvider[];
+    readonly promptBuilder?: PromptBuilder;
+    readonly skills?: readonly Skill[];
+    readonly tools?: readonly ToolDefinition[];
+    readonly providerOptions?: ProviderRequestOptions;
+}
+export declare function createDefaultInputBuilder(): DefaultInputBuilder;
+export declare function resolveContextProviders(options: ResolveContextOptions): Promise<readonly ContextBlock[]>;
+export declare function createDefaultPromptBuilder(): DefaultPromptBuilder;
+export declare function renderPromptTemplate(template: string, variables: JsonObject, options?: PromptTemplateOptions): string;
+export declare function assembleProviderInput(options: AssembleProviderInputOptions): Promise<ProviderRequest>;