@arnilo/prism 0.0.1

package/dist/input.js

@@ -0,0 +1,225 @@
+import { loadTextResource } from "./resources.js";
+export function createDefaultInputBuilder() {
+    return {
+        name: "default-input",
+        async build(input, context = {}) {
+            const messages = [];
+            messages.push(...instructionMessages(context.systemInstructions, "System instruction"));
+            messages.push(...instructionMessages(context.developerInstructions, "Developer instruction"));
+            messages.push(...customInstructionMessages(context.instructions));
+            messages.push(...summaryMessages(context.summaries));
+            messages.push(...(context.history ?? []));
+            messages.push(...inputMessages(input));
+            messages.push(...await attachmentMessages(context));
+            messages.push(...toolResultMessages(context.toolResults));
+            return context.middleware ? context.middleware.run("input_assembly", messages) : messages;
+        },
+    };
+}
+export async function resolveContextProviders(options) {
+    const blocks = [];
+    for (const provider of options.providers ?? []) {
+        throwIfAborted(options.signal);
+        blocks.push(...await provider.resolve({
+            sessionId: options.sessionId,
+            runId: options.runId,
+            messages: options.messages,
+            metadata: options.metadata,
+            signal: options.signal,
+        }));
+    }
+    return options.middleware ? options.middleware.run("context", blocks) : blocks;
+}
+export function createDefaultPromptBuilder() {
+    return {
+        name: "default-prompt",
+        async build(request) {
+            return [
+                ...contextMessages(request.context),
+                ...skillMessages(request.skills),
+                ...toolMessages(request.tools),
+                ...request.messages,
+            ];
+        },
+    };
+}
+export function renderPromptTemplate(template, variables, options = {}) {
+    return template.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (match, name) => {
+        if (!Object.prototype.hasOwnProperty.call(variables, name)) {
+            if (options.missing === "preserve")
+                return match;
+            throw new Error(`Missing prompt template variable: ${name}`);
+        }
+        return templateValue(variables[name]);
+    });
+}
+export async function assembleProviderInput(options) {
+    const inputBuilder = options.inputBuilder ?? createDefaultInputBuilder();
+    const baseContext = {
+        sessionId: options.sessionId,
+        runId: options.runId,
+        metadata: options.metadata,
+        signal: options.signal,
+    };
+    const messages = await inputBuilder.build(options.input, { ...options, ...baseContext });
+    const context = await resolveContextProviders({
+        providers: options.contextProviders,
+        messages,
+        middleware: options.middleware,
+        ...baseContext,
+    });
+    const promptBuilder = options.promptBuilder ?? createDefaultPromptBuilder();
+    const promptRequest = options.middleware
+        ? await options.middleware.run("prompt_build", {
+            messages,
+            context,
+            skills: options.skills,
+            tools: options.tools,
+            metadata: options.metadata,
+            signal: options.signal,
+        })
+        : {
+            messages,
+            context,
+            skills: options.skills,
+            tools: options.tools,
+            metadata: options.metadata,
+            signal: options.signal,
+        };
+    const providerMessages = await promptBuilder.build({ ...promptRequest, tools: options.tools });
+    return {
+        model: options.model,
+        messages: providerMessages,
+        tools: options.tools,
+        context,
+        options: options.providerOptions,
+        metadata: options.metadata,
+        signal: options.signal,
+    };
+}
+function inputMessages(input) {
+    if (typeof input === "string")
+        return [textMessage("user", input)];
+    if ("role" in input)
+        return [input];
+    return [...input];
+}
+function instructionMessages(value, label) {
+    const items = typeof value === "string" ? [value] : value ?? [];
+    return items.map((text) => textMessage("system", `${label}:\n${text}`));
+}
+function customInstructionMessages(value) {
+    if (!value)
+        return [];
+    if (typeof value === "string")
+        return [textMessage("system", value)];
+    const items = Array.isArray(value) ? value : [value];
+    return items.map((item) => textMessage("system", item.label ? `${item.label}:\n${item.text}` : item.text, item.metadata));
+}
+function summaryMessages(summaries) {
+    return (summaries ?? []).map((summary) => {
+        if (typeof summary === "string")
+            return textMessage("system", `Summary:\n${summary}`);
+        const content = typeof summary.content === "string" ? [{ type: "text", text: summary.content }] : summary.content;
+        return { role: "system", content, metadata: summary.metadata };
+    });
+}
+async function attachmentMessages(context) {
+    const messages = [];
+    for (const attachment of context.attachments ?? []) {
+        if (attachment.content) {
+            messages.push({ role: "user", content: attachment.content, metadata: attachmentMetadata(attachment) });
+            continue;
+        }
+        if (attachment.text !== undefined) {
+            messages.push(textMessage("user", attachment.name ? `Attachment ${attachment.name}:\n${attachment.text}` : attachment.text, attachmentMetadata(attachment)));
+            continue;
+        }
+        if (attachment.uri)
+            messages.push(await resourceMessage(attachment.uri, context, attachment));
+    }
+    for (const uri of context.resourceUris ?? [])
+        messages.push(await resourceMessage(uri, context));
+    return messages;
+}
+async function resourceMessage(uri, context, attachment) {
+    if (!context.resourceLoader)
+        throw new Error(`Resource loader required for ${uri}`);
+    const text = await loadTextResource(context.resourceLoader, uri, {
+        signal: context.signal,
+        metadata: context.metadata,
+    });
+    const label = attachment?.name ?? uri;
+    return textMessage("user", `Resource ${label}:\n${text}`, attachmentMetadata({ ...attachment, uri }));
+}
+function toolResultMessages(results) {
+    return (results ?? []).map((result) => ({
+        role: "tool",
+        content: [{
+                type: "tool_result",
+                toolCallId: result.toolCallId,
+                name: result.name,
+                result: result.value,
+                error: result.error,
+            }, ...(result.content ?? [])],
+        metadata: result.metadata,
+    }));
+}
+function textMessage(role, text, metadata) {
+    return { role, content: [{ type: "text", text }], metadata };
+}
+function contextMessages(context) {
+    return (context ?? []).map((block) => textMessage("system", `${block.title ? `${block.title}:\n` : "Context:\n"}${blockText(block)}`, block.metadata));
+}
+function skillMessages(skills) {
+    return (skills ?? [])
+        .filter((skill) => skill.instructions)
+        .map((skill) => textMessage("system", `Skill ${skill.name}:\n${skill.instructions}`, skill.metadata));
+}
+function toolMessages(tools) {
+    if (!tools?.length)
+        return [];
+    return [textMessage("system", `Available tools:\n${tools.map((tool) => `- ${tool.name}${tool.description ? `: ${tool.description}` : ""}`).join("\n")}`)];
+}
+function blockText(block) {
+    if (typeof block.content === "string")
+        return block.content;
+    return block.content.map((part) => {
+        if (part.type === "text" || part.type === "thinking")
+            return part.text;
+        if (part.type === "tool_result")
+            return JSON.stringify(part.result ?? part.error ?? null);
+        if (part.type === "tool_call")
+            return `${part.name}(${JSON.stringify(part.arguments)})`;
+        return part.url ?? part.mimeType ?? "[image]";
+    }).join("\n");
+}
+function templateValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || value === null)
+        return String(value);
+    return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortJson(value[key])]));
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw new Error("Context resolution aborted");
+}
+function attachmentMetadata(attachment) {
+    if (!attachment)
+        return undefined;
+    return {
+        ...attachment.metadata,
+        ...(attachment.name ? { name: attachment.name } : {}),
+        ...(attachment.uri ? { uri: attachment.uri } : {}),
+        ...(attachment.mediaType ? { mediaType: attachment.mediaType } : {}),
+    };
+}
+//# sourceMappingURL=input.js.map

package/dist/manifests.d.ts

@@ -0,0 +1,28 @@
+import type { JsonObject } from "./contracts.js";
+export type ManifestContributionKind = "provider" | "model" | "tool" | "contextProvider" | "skill" | "command" | "agent" | "inputBuilder" | "promptBuilder" | "compactionStrategy" | "retryPolicy" | "storeFactory" | "resourceLoader" | "settingsProvider" | "credentialResolver" | "providerPackage" | "authMethod" | "providerRequestPolicy" | "systemPromptContribution";
+export interface ManifestContributionDeclaration {
+    readonly kind: ManifestContributionKind;
+    readonly name: string;
+    readonly module?: string;
+    readonly exportName?: string;
+    readonly configKey?: string;
+    readonly resource?: string;
+    readonly metadata?: JsonObject;
+}
+export interface ManifestResourceDeclaration {
+    readonly uri: string;
+    readonly mediaType?: string;
+    readonly purpose?: "manifest" | "prompt" | "skill" | "package" | string;
+    readonly metadata?: JsonObject;
+}
+export interface PrismManifest {
+    readonly name: string;
+    readonly version?: string;
+    readonly description?: string;
+    readonly configDefaults?: JsonObject;
+    readonly contributions?: readonly ManifestContributionDeclaration[];
+    readonly resources?: readonly ManifestResourceDeclaration[];
+    readonly metadata?: JsonObject;
+}
+export declare function definePrismManifest(manifest: PrismManifest): PrismManifest;
+export declare function parsePrismManifest(value: unknown): PrismManifest;

package/dist/manifests.js

@@ -0,0 +1,108 @@
+import { assertJsonObject, isJsonObject } from "./config.js";
+export function definePrismManifest(manifest) {
+    return parsePrismManifest(manifest);
+}
+export function parsePrismManifest(value) {
+    if (!isRecord(value))
+        throw new Error("manifest must be an object");
+    const manifest = value;
+    const name = readRequiredString(manifest, "name");
+    const parsed = {
+        name,
+        ...readOptionalString(manifest, "version"),
+        ...readOptionalString(manifest, "description"),
+        ...readOptionalJsonObject(manifest, "configDefaults"),
+        contributions: readContributions(manifest.contributions),
+        resources: readResources(manifest.resources),
+        ...readOptionalJsonObject(manifest, "metadata"),
+    };
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readContributions(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new Error("manifest.contributions must be an array");
+    return value.map((item, index) => {
+        assertJsonObject(item, `manifest.contributions[${index}]`);
+        const contribution = item;
+        return {
+            kind: readKind(contribution.kind, index),
+            name: readRequiredString(contribution, "name", `manifest.contributions[${index}].name`),
+            ...readOptionalString(contribution, "module", `manifest.contributions[${index}].module`),
+            ...readOptionalString(contribution, "exportName", `manifest.contributions[${index}].exportName`),
+            ...readOptionalString(contribution, "configKey", `manifest.contributions[${index}].configKey`),
+            ...readOptionalString(contribution, "resource", `manifest.contributions[${index}].resource`),
+            ...readOptionalJsonObject(contribution, "metadata", `manifest.contributions[${index}].metadata`),
+        };
+    });
+}
+function readResources(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        throw new Error("manifest.resources must be an array");
+    return value.map((item, index) => {
+        assertJsonObject(item, `manifest.resources[${index}]`);
+        const resource = item;
+        return {
+            uri: readRequiredString(resource, "uri", `manifest.resources[${index}].uri`),
+            ...readOptionalString(resource, "mediaType", `manifest.resources[${index}].mediaType`),
+            ...readOptionalString(resource, "purpose", `manifest.resources[${index}].purpose`),
+            ...readOptionalJsonObject(resource, "metadata", `manifest.resources[${index}].metadata`),
+        };
+    });
+}
+function readKind(value, index) {
+    const kinds = new Set([
+        "provider",
+        "model",
+        "tool",
+        "contextProvider",
+        "skill",
+        "command",
+        "agent",
+        "inputBuilder",
+        "promptBuilder",
+        "compactionStrategy",
+        "retryPolicy",
+        "storeFactory",
+        "resourceLoader",
+        "settingsProvider",
+        "credentialResolver",
+        "providerPackage",
+        "authMethod",
+        "providerRequestPolicy",
+        "systemPromptContribution",
+    ]);
+    if (typeof value !== "string" || !kinds.has(value)) {
+        throw new Error(`manifest.contributions[${index}].kind must be a known contribution kind`);
+    }
+    return value;
+}
+function readRequiredString(record, key, label = `manifest.${key}`) {
+    const value = record[key];
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`${label} must be a non-empty string`);
+    return value;
+}
+function readOptionalString(record, key, label = `manifest.${key}`) {
+    const value = record[key];
+    if (value === undefined)
+        return {};
+    if (typeof value !== "string")
+        throw new Error(`${label} must be a string`);
+    return { [key]: value };
+}
+function readOptionalJsonObject(record, key, label = `manifest.${key}`) {
+    const value = record[key];
+    if (value === undefined)
+        return {};
+    if (!isJsonObject(value))
+        throw new Error(`${label} must be a JSON object`);
+    return { [key]: value };
+}
+//# sourceMappingURL=manifests.js.map

package/dist/middleware.d.ts

@@ -0,0 +1,15 @@
+import type { ExtensionEvent } from "./contracts.js";
+export type MiddlewareHookName = "provider_request" | "input_assembly" | "prompt_build" | "context" | "tool_call" | "tool_result" | "retry" | "compaction" | "session_start" | "session_shutdown";
+export type MiddlewareNext<T> = (value: T) => Promise<T>;
+export type Middleware<T = unknown> = (value: T, next: MiddlewareNext<T>) => T | Promise<T>;
+export interface MiddlewareRegistryOptions {
+    readonly errorPolicy?: "event" | "throw";
+    readonly secrets?: readonly (string | undefined)[];
+    readonly onError?: (event: ExtensionEvent) => void | Promise<void>;
+}
+export interface MiddlewareRegistry {
+    use<T>(hook: MiddlewareHookName | string, middleware: Middleware<T>): () => void;
+    run<T>(hook: MiddlewareHookName | string, value: T): Promise<T>;
+    list(hook: MiddlewareHookName | string): readonly Middleware[];
+}
+export declare function createMiddlewareRegistry(options?: MiddlewareRegistryOptions): MiddlewareRegistry;

package/dist/middleware.js

@@ -0,0 +1,49 @@
+import { errorToErrorInfo } from "./redaction.js";
+function middlewareError(error, hook, secrets) {
+    return { type: "extension_error", extension: `middleware:${hook}`, error: errorToErrorInfo(error, secrets) };
+}
+export function createMiddlewareRegistry(options = {}) {
+    const byHook = new Map();
+    const errorPolicy = options.errorPolicy ?? "event";
+    const secrets = options.secrets ?? [];
+    return {
+        use(hook, middleware) {
+            const list = byHook.get(hook) ?? [];
+            list.push(middleware);
+            byHook.set(hook, list);
+            return () => {
+                const next = (byHook.get(hook) ?? []).filter((item) => item !== middleware);
+                if (next.length === 0)
+                    byHook.delete(hook);
+                else
+                    byHook.set(hook, next);
+            };
+        },
+        async run(hook, value) {
+            let current = value;
+            for (const middleware of byHook.get(hook) ?? []) {
+                try {
+                    let calledNext = false;
+                    const next = async (nextValue) => {
+                        calledNext = true;
+                        current = nextValue;
+                        return current;
+                    };
+                    const result = await middleware(current, next);
+                    if (!calledNext)
+                        current = result;
+                }
+                catch (error) {
+                    if (errorPolicy === "throw")
+                        throw error;
+                    await options.onError?.(middlewareError(error, hook, secrets));
+                }
+            }
+            return current;
+        },
+        list(hook) {
+            return [...(byHook.get(hook) ?? [])];
+        },
+    };
+}
+//# sourceMappingURL=middleware.js.map

package/dist/mock-provider.d.ts

@@ -0,0 +1,6 @@
+import type { AIProvider, ProviderEvent, ProviderRequest } from "./contracts.js";
+export interface MockProviderOptions {
+    readonly id?: string;
+    readonly onRequest?: (request: ProviderRequest) => void;
+}
+export declare function createMockProvider(events?: readonly ProviderEvent[], options?: MockProviderOptions): AIProvider;

package/dist/mock-provider.js

@@ -0,0 +1,14 @@
+export function createMockProvider(events = [{ type: "done" }], options = {}) {
+    return {
+        id: options.id ?? "mock",
+        async *generate(request) {
+            options.onRequest?.(request);
+            for (const event of events) {
+                if (request.signal?.aborted)
+                    throw request.signal.reason;
+                yield event;
+            }
+        },
+    };
+}
+//# sourceMappingURL=mock-provider.js.map

package/dist/models.d.ts

@@ -0,0 +1,8 @@
+import type { ModelConfig } from "./contracts.js";
+export interface ModelRegistry {
+    register(model: ModelConfig): void;
+    get(provider: string, model: string): ModelConfig | undefined;
+    resolve(provider: string, model: string): ModelConfig;
+    list(): readonly ModelConfig[];
+}
+export declare function createModelRegistry(models?: readonly ModelConfig[]): ModelRegistry;

package/dist/models.js

@@ -0,0 +1,25 @@
+export function createModelRegistry(models = []) {
+    const byId = new Map();
+    const key = (provider, model) => `${provider}\0${model}`;
+    const registry = {
+        register(model) {
+            byId.set(key(model.provider, model.model), model);
+        },
+        get(provider, model) {
+            return byId.get(key(provider, model));
+        },
+        resolve(provider, model) {
+            const config = byId.get(key(provider, model));
+            if (!config)
+                throw new Error(`Unknown model: ${provider}/${model}`);
+            return config;
+        },
+        list() {
+            return [...byId.values()];
+        },
+    };
+    for (const model of models)
+        registry.register(model);
+    return registry;
+}
+//# sourceMappingURL=models.js.map

package/dist/node/config.d.ts

@@ -0,0 +1,9 @@
+import { type ConfigLayer } from "../config.js";
+export interface NodeConfigFile {
+    readonly name: string;
+    readonly path: string;
+    readonly optional?: boolean;
+}
+export declare function defaultUserConfigPath(appName?: string): string;
+export declare function readConfigFile(path: string): Promise<ConfigLayer["config"]>;
+export declare function loadConfigFiles(files: readonly NodeConfigFile[]): Promise<ConfigLayer[]>;

package/dist/node/config.js

@@ -0,0 +1,51 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { assertJsonObject } from "../config.js";
+export function defaultUserConfigPath(appName = "prism") {
+    return join(homedir(), ".config", appName, "config.json");
+}
+export async function readConfigFile(path) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        throw new Error(`Failed to read config ${path}: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON config ${path}: ${errorMessage(error)}`);
+    }
+    try {
+        assertJsonObject(parsed, `config ${path}`);
+    }
+    catch (error) {
+        throw new Error(errorMessage(error));
+    }
+    return parsed;
+}
+export async function loadConfigFiles(files) {
+    const layers = [];
+    for (const file of files) {
+        try {
+            layers.push({ name: file.name, config: await readConfigFile(file.path) });
+        }
+        catch (error) {
+            if (file.optional && isMissingFile(error))
+                continue;
+            throw error;
+        }
+    }
+    return layers;
+}
+function isMissingFile(error) {
+    return error instanceof Error && error.message.includes("ENOENT");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=config.js.map

package/dist/node/session-store-jsonl.d.ts

@@ -0,0 +1,17 @@
+import type { SessionEntry, SessionStore } from "../contracts.js";
+export interface JsonlSessionStoreOptions {
+    readonly path: string;
+    readonly createDirectory?: boolean;
+}
+export interface SessionEntryParseError {
+    readonly line: number;
+    readonly message: string;
+    readonly raw?: string;
+}
+export interface SessionEntryReadResult {
+    readonly entries: SessionEntry[];
+    readonly errors: SessionEntryParseError[];
+}
+export declare function createJsonlSessionStore(pathOrOptions: string | JsonlSessionStoreOptions): SessionStore;
+/** Read a JSONL session file and return both valid entries and per-line parse errors. */
+export declare function readJsonlSessionEntries(path: string): Promise<SessionEntryReadResult>;