@arnilo/prism 0.0.1

package/dist/node/session-store-jsonl.js

@@ -0,0 +1,134 @@
+import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export function createJsonlSessionStore(pathOrOptions) {
+    const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
+    const path = options.path;
+    let appendChain = Promise.resolve();
+    return {
+        append(entry) {
+            appendChain = appendChain.then(async () => {
+                if (options.createDirectory !== false)
+                    await mkdir(dirname(path), { recursive: true });
+                if (await findEntry(path, entry.id))
+                    throw new Error(`Duplicate session entry id: ${entry.id}`);
+                await appendFile(path, `${JSON.stringify(entry)}\n`, "utf8");
+            });
+            return appendChain;
+        },
+        async list(sessionId) {
+            return (await readEntries(path)).filter((entry) => entry.sessionId === sessionId);
+        },
+        async get(id) {
+            return findEntry(path, id);
+        },
+    };
+}
+/** Read a JSONL session file and return both valid entries and per-line parse errors. */
+export async function readJsonlSessionEntries(path) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return { entries: [], errors: [] };
+        throw new Error(`Failed to read session store ${path}: ${errorMessage(error)}`);
+    }
+    const entries = [];
+    const errors = [];
+    for (const [index, line] of text.split(/\r?\n/).filter(Boolean).entries()) {
+        const parsed = parseEntry(line, index + 1);
+        if (parsed.ok) {
+            entries.push(parsed.entry);
+        }
+        else {
+            errors.push(parsed.error);
+        }
+    }
+    return { entries, errors };
+}
+async function findEntry(path, id) {
+    return (await readEntries(path)).find((entry) => entry.id === id);
+}
+async function readEntries(path) {
+    return (await readJsonlSessionEntries(path)).entries;
+}
+function parseEntry(line, lineNumber) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        return { ok: false, error: { line: lineNumber, message: `Invalid JSON: ${errorMessage(error)}`, raw: line } };
+    }
+    return validateSessionEntry(parsed, lineNumber, line);
+}
+function validateSessionEntry(value, lineNumber, raw) {
+    if (!isBasicSessionEntry(value)) {
+        return { ok: false, error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw } };
+    }
+    const entry = value;
+    if (entry.parentId !== undefined && typeof entry.parentId !== "string") {
+        return { ok: false, error: { line: lineNumber, message: "Invalid parentId: expected string", raw } };
+    }
+    switch (entry.kind) {
+        case "message":
+            if (!isMessage(entry.message))
+                return { ok: false, error: { line: lineNumber, message: "Invalid message entry: expected Message object", raw } };
+            break;
+        case "summary":
+            if (typeof entry.summary !== "string")
+                return { ok: false, error: { line: lineNumber, message: "Invalid summary entry: expected string summary", raw } };
+            break;
+        case "model_change":
+            if (!isModelConfig(entry.model))
+                return { ok: false, error: { line: lineNumber, message: "Invalid model_change entry: expected ModelConfig object", raw } };
+            break;
+        case "custom":
+            if (!isPlainObject(entry.data))
+                return { ok: false, error: { line: lineNumber, message: "Invalid custom entry: expected object data", raw } };
+            break;
+        case "compaction":
+            if (typeof entry.summary !== "string")
+                return { ok: false, error: { line: lineNumber, message: "Invalid compaction entry: expected string summary", raw } };
+            if (!isPlainObject(entry.data))
+                return { ok: false, error: { line: lineNumber, message: "Invalid compaction entry: expected object data", raw } };
+            break;
+        case "label":
+            if (typeof entry.label !== "string")
+                return { ok: false, error: { line: lineNumber, message: "Invalid label entry: expected string label", raw } };
+            break;
+    }
+    return { ok: true, entry };
+}
+function isBasicSessionEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const entry = value;
+    return typeof entry.id === "string"
+        && typeof entry.sessionId === "string"
+        && typeof entry.timestamp === "string"
+        && typeof entry.kind === "string";
+}
+function isMessage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const message = value;
+    return typeof message.role === "string" && Array.isArray(message.content);
+}
+function isModelConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const model = value;
+    return typeof model.provider === "string" && typeof model.model === "string";
+}
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=session-store-jsonl.js.map

package/dist/node/settings.d.ts

@@ -0,0 +1,7 @@
+import { type ConfigLayer } from "../config.js";
+import { type NodeConfigFile } from "./config.js";
+import type { SettingsProvider } from "../contracts.js";
+export type NodeSettingsFile = NodeConfigFile;
+export declare function defaultUserSettingsPath(appName?: string): string;
+export declare function readSettingsFile(path: string): Promise<ConfigLayer["config"]>;
+export declare function loadSettingsFiles(files: readonly NodeSettingsFile[]): Promise<SettingsProvider>;

package/dist/node/settings.js

@@ -0,0 +1,26 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mergeConfigLayers } from "../config.js";
+import { readConfigFile } from "./config.js";
+import { createStaticSettingsProvider } from "../settings.js";
+export function defaultUserSettingsPath(appName = "prism") {
+    return join(homedir(), ".config", appName, "settings.json");
+}
+export function readSettingsFile(path) {
+    return readConfigFile(path);
+}
+export async function loadSettingsFiles(files) {
+    const layers = [];
+    for (const file of files) {
+        try {
+            layers.push({ name: file.name, config: await readSettingsFile(file.path) });
+        }
+        catch (error) {
+            if (file.optional && error instanceof Error && error.message.includes("ENOENT"))
+                continue;
+            throw error;
+        }
+    }
+    return createStaticSettingsProvider(mergeConfigLayers(layers));
+}
+//# sourceMappingURL=settings.js.map

package/dist/node/trust.d.ts

@@ -0,0 +1,13 @@
+import type { TrustPolicy } from "../security.js";
+export interface PathTrustPolicyOptions {
+    readonly trustedRoots: readonly string[];
+}
+export declare function isPathInside(root: string, target: string): boolean;
+/** Async path-inside check that resolves symlinks on both root and target.
+ *  Fails closed (returns false) if the root cannot be resolved, if realpath fails
+ *  for another reason, or if the resolved target escapes the resolved root.
+ *  If the target itself does not exist, its parent directory is resolved instead
+ *  so that write-time trust checks can still validate the path.
+ */
+export declare function isPathInsideReal(root: string, target: string): Promise<boolean>;
+export declare function createPathTrustPolicy(options: PathTrustPolicyOptions): TrustPolicy;

package/dist/node/trust.js

@@ -0,0 +1,56 @@
+import { isAbsolute, relative, resolve, dirname, basename, join } from "node:path";
+import { realpath } from "node:fs/promises";
+export function isPathInside(root, target) {
+    const from = resolve(root);
+    const to = resolve(target);
+    const rel = relative(from, to);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+/** Async path-inside check that resolves symlinks on both root and target.
+ *  Fails closed (returns false) if the root cannot be resolved, if realpath fails
+ *  for another reason, or if the resolved target escapes the resolved root.
+ *  If the target itself does not exist, its parent directory is resolved instead
+ *  so that write-time trust checks can still validate the path.
+ */
+export async function isPathInsideReal(root, target) {
+    let from;
+    try {
+        from = await realpath(root);
+    }
+    catch {
+        return false;
+    }
+    let to;
+    try {
+        to = await realpath(target);
+    }
+    catch (error) {
+        if (!isMissingFile(error))
+            return false;
+        const parent = dirname(target);
+        try {
+            const resolvedParent = await realpath(parent);
+            to = join(resolvedParent, basename(target));
+        }
+        catch {
+            return false;
+        }
+    }
+    return isPathInside(from, to);
+}
+export function createPathTrustPolicy(options) {
+    return {
+        async check(request) {
+            for (const root of options.trustedRoots) {
+                if (await isPathInsideReal(root, request.target)) {
+                    return { trusted: true };
+                }
+            }
+            return { trusted: false, reason: `Path is outside trusted roots: ${request.target}` };
+        },
+    };
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+//# sourceMappingURL=trust.js.map

package/dist/provider-events.d.ts

@@ -0,0 +1,15 @@
+import type { ContentBlock, JsonObject, ProviderEvent, ToolCallContent, Usage } from "./contracts.js";
+export declare function providerTextDelta(text: string): ProviderEvent;
+export declare function providerThinkingDelta(text: string, signature?: string): ProviderEvent;
+export declare function providerContentDelta(content: ContentBlock): ProviderEvent;
+export declare function providerToolCall(call: ToolCallContent): ProviderEvent;
+export declare function providerToolCallDelta(delta: {
+    readonly index: number;
+    readonly id?: string;
+    readonly name?: string;
+    readonly argumentsText?: string;
+}): ProviderEvent;
+export declare function providerUsage(usage: Usage): ProviderEvent;
+export declare function providerDone(usage?: Usage): ProviderEvent;
+export declare function providerError(error: unknown, secrets?: readonly (string | undefined)[]): ProviderEvent;
+export declare function toolCallContent(id: string, name: string, args?: JsonObject): ToolCallContent;

package/dist/provider-events.js

@@ -0,0 +1,30 @@
+import { errorToErrorInfo } from "./redaction.js";
+export function providerTextDelta(text) {
+    return { type: "content_delta", content: { type: "text", text } };
+}
+export function providerThinkingDelta(text, signature) {
+    return { type: "content_delta", content: { type: "thinking", text, signature } };
+}
+export function providerContentDelta(content) {
+    return { type: "content_delta", content };
+}
+export function providerToolCall(call) {
+    return { type: "tool_call", call };
+}
+export function providerToolCallDelta(delta) {
+    return { type: "tool_call_delta", ...delta };
+}
+export function providerUsage(usage) {
+    return { type: "usage", usage };
+}
+export function providerDone(usage) {
+    return { type: "done", usage };
+}
+export function providerError(error, secrets = []) {
+    const info = errorToErrorInfo(error, secrets);
+    return { type: "error", error: info };
+}
+export function toolCallContent(id, name, args = {}) {
+    return { type: "tool_call", id, name, arguments: args };
+}
+//# sourceMappingURL=provider-events.js.map

package/dist/provider-packages.d.ts

@@ -0,0 +1,4 @@
+import type { AuthMethod, ProviderPackage, SystemPromptContribution } from "./contracts.js";
+export declare function defineProviderPackage(providerPackage: ProviderPackage): ProviderPackage;
+export declare function authMethodKey(method: AuthMethod): string;
+export declare function systemPromptContributionKey(contribution: SystemPromptContribution): string;

package/dist/provider-packages.js

@@ -0,0 +1,12 @@
+export function defineProviderPackage(providerPackage) {
+    if (!providerPackage.name.trim())
+        throw new Error("Provider package name is required");
+    return providerPackage;
+}
+export function authMethodKey(method) {
+    return `${method.provider}\0${method.name ?? method.kind}`;
+}
+export function systemPromptContributionKey(contribution) {
+    return contribution.id;
+}
+//# sourceMappingURL=provider-packages.js.map

package/dist/provider-request-policy.d.ts

@@ -0,0 +1,9 @@
+import type { CacheRetention, ProviderRequest, ProviderRequestOptions, ProviderRequestPolicy, ProviderRequestPolicyResult } from "./contracts.js";
+export interface SessionCachePolicyOptions {
+    readonly retention?: CacheRetention;
+    readonly cacheKey?: string;
+}
+export declare function createProviderRequestPolicyChain(policies: readonly ProviderRequestPolicy[]): ProviderRequestPolicy;
+export declare function createSessionCachePolicy(options?: SessionCachePolicyOptions): ProviderRequestPolicy;
+export declare function mergeProviderRequestOptions(base: ProviderRequestOptions | undefined, patch: ProviderRequestOptions | undefined): ProviderRequestOptions | undefined;
+export declare function normalizeProviderRequestPolicyResult(result: ProviderRequest | ProviderRequestPolicyResult): ProviderRequestPolicyResult;

package/dist/provider-request-policy.js

@@ -0,0 +1,49 @@
+export function createProviderRequestPolicyChain(policies) {
+    return {
+        name: "provider-request-policy-chain",
+        async apply(context) {
+            let request = context.request;
+            const secrets = [];
+            for (const policy of policies) {
+                const result = await policy.apply({ ...context, request });
+                const normalized = normalizeProviderRequestPolicyResult(result);
+                request = normalized.request;
+                secrets.push(...(normalized.secrets ?? []));
+            }
+            return { request, secrets };
+        },
+    };
+}
+export function createSessionCachePolicy(options = {}) {
+    return {
+        name: "session-cache",
+        apply(context) {
+            const sessionId = context.request.options?.sessionId ?? context.sessionId;
+            return {
+                ...context.request,
+                options: mergeProviderRequestOptions(context.request.options, {
+                    sessionId,
+                    cacheKey: options.cacheKey ?? sessionId,
+                    cacheRetention: options.retention ?? "short",
+                }),
+            };
+        },
+    };
+}
+export function mergeProviderRequestOptions(base, patch) {
+    if (!base)
+        return patch;
+    if (!patch)
+        return base;
+    return {
+        ...base,
+        ...patch,
+        headers: patch.headers || base.headers ? { ...base.headers, ...patch.headers } : undefined,
+        compat: patch.compat || base.compat ? { ...base.compat, ...patch.compat } : undefined,
+        extra: patch.extra || base.extra ? { ...base.extra, ...patch.extra } : undefined,
+    };
+}
+export function normalizeProviderRequestPolicyResult(result) {
+    return "request" in result ? result : { request: result };
+}
+//# sourceMappingURL=provider-request-policy.js.map

package/dist/providers/openai-compatible.d.ts

@@ -0,0 +1,9 @@
+import type { AIProvider } from "../contracts.js";
+import { type CredentialValueSource } from "../credentials.js";
+export interface OpenAICompatibleProviderOptions {
+    readonly id?: string;
+    readonly baseUrl: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+}
+export declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): AIProvider;

package/dist/providers/openai-compatible.js

@@ -0,0 +1,197 @@
+import { resolveCredentialValue } from "../credentials.js";
+import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallContent, } from "../provider-events.js";
+import { redactSecrets } from "../redaction.js";
+export function createOpenAICompatibleProvider(options) {
+    const providerId = options.id ?? "openai-compatible";
+    return {
+        id: providerId,
+        async *generate(request) {
+            const apiKey = await resolveCredentialValue(options.apiKey, {
+                name: "apiKey",
+                provider: providerId,
+            });
+            const fetchImpl = options.fetch ?? fetch;
+            const secrets = [apiKey];
+            const tools = new Map();
+            try {
+                const response = await fetchImpl(`${options.baseUrl.replace(/\/$/, "")}/chat/completions`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        ...request.options?.headers,
+                        ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
+                    },
+                    body: JSON.stringify(toOpenAIRequest(request)),
+                    signal: request.signal,
+                });
+                if (!response.ok) {
+                    yield providerError(new Error(`OpenAI-compatible request failed: ${response.status} ${await safeText(response)}`), secrets);
+                    return;
+                }
+                if (!response.body) {
+                    yield providerError(new Error("OpenAI-compatible response had no body"), secrets);
+                    return;
+                }
+                for await (const data of readSseData(response.body)) {
+                    if (data === "[DONE]")
+                        break;
+                    const parsed = JSON.parse(data);
+                    const usage = toUsage(parsed.usage);
+                    if (usage)
+                        yield providerUsage(usage);
+                    for (const choice of parsed.choices ?? []) {
+                        const delta = choice.delta ?? {};
+                        if (typeof delta.content === "string" && delta.content)
+                            yield providerTextDelta(delta.content);
+                        if (typeof delta.reasoning_content === "string" && delta.reasoning_content) {
+                            yield providerThinkingDelta(delta.reasoning_content);
+                        }
+                        for (const tool of delta.tool_calls ?? []) {
+                            const index = tool.index ?? 0;
+                            const current = tools.get(index) ?? { argumentsText: "" };
+                            current.id = tool.id ?? current.id;
+                            current.name = tool.function?.name ?? current.name;
+                            current.argumentsText += tool.function?.arguments ?? "";
+                            tools.set(index, current);
+                            yield providerToolCallDelta({
+                                index,
+                                id: tool.id,
+                                name: tool.function?.name,
+                                argumentsText: tool.function?.arguments,
+                            });
+                        }
+                    }
+                }
+                for (const call of tools.values()) {
+                    if (call.id && call.name)
+                        yield providerToolCall(toolCallContent(call.id, call.name, parseArgs(call.argumentsText)));
+                }
+                yield providerDone();
+            }
+            catch (error) {
+                yield providerError(error, secrets);
+            }
+        },
+    };
+}
+function toOpenAIRequest(request) {
+    return {
+        model: request.model.model,
+        messages: request.messages.map((message) => toOpenAIMessage(message, request.model.capabilities ?? {})),
+        tools: request.tools?.map(toOpenAITool),
+        stream: true,
+        stream_options: { include_usage: true },
+        ...request.model.parameters,
+    };
+}
+function toOpenAIMessage(message, capabilities = {}) {
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return {
+            role: "tool",
+            tool_call_id: result?.toolCallId ?? "",
+            content: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+        };
+    }
+    if (message.role === "assistant") {
+        const toolCalls = message.content.filter((part) => part.type === "tool_call");
+        const textParts = message.content.filter((part) => part.type === "text" || part.type === "thinking");
+        if (toolCalls.length > 0) {
+            return {
+                role: "assistant",
+                content: textParts.map((part) => (part.type === "text" ? part.text : part.text)).join("\n") || null,
+                tool_calls: toolCalls.map((call) => ({
+                    id: call.id,
+                    type: "function",
+                    function: { name: call.name, arguments: JSON.stringify(call.arguments) },
+                })),
+            };
+        }
+    }
+    const content = [];
+    for (const part of message.content) {
+        if (part.type === "text" || part.type === "thinking") {
+            content.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "image") {
+            if (!capabilities.input?.includes("image")) {
+                throw new Error(`Provider ${message.role} message includes image but model does not declare image input capability`);
+            }
+            content.push(toOpenAIImage(part));
+        }
+        else if (part.type === "tool_call") {
+            throw new Error("Provider assistant tool_call blocks must be the only content on the message");
+        }
+        else if (part.type === "tool_result") {
+            throw new Error("Provider tool_result blocks must appear in role=tool messages");
+        }
+    }
+    if (content.length === 1 && content[0].type === "text") {
+        return { role: message.role, content: content[0].text };
+    }
+    return { role: message.role, content };
+}
+function toOpenAIImage(part) {
+    const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
+    if (!url)
+        throw new Error("Provider image block missing url or data");
+    return { type: "image_url", image_url: { url } };
+}
+function toOpenAITool(tool) {
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters ?? { type: "object" },
+        },
+    };
+}
+async function* readSseData(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.startsWith("data: "))
+                yield line.slice(6).trim();
+        }
+    }
+    buffer += decoder.decode();
+    for (const line of buffer.split(/\r?\n/)) {
+        if (line.startsWith("data: "))
+            yield line.slice(6).trim();
+    }
+}
+async function safeText(response) {
+    try {
+        return redactSecrets(await response.text(), []);
+    }
+    catch {
+        return "";
+    }
+}
+function parseArgs(text) {
+    if (!text)
+        return {};
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function toUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens,
+        cacheReadTokens: usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens,
+        cacheWriteTokens: usage.prompt_tokens_details?.cache_write_tokens,
+    };
+}
+//# sourceMappingURL=openai-compatible.js.map

package/dist/providers.d.ts

@@ -0,0 +1,8 @@
+import type { AIProvider, ModelConfig } from "./contracts.js";
+export interface ProviderRegistry {
+    register(provider: AIProvider): void;
+    get(id: string): AIProvider | undefined;
+    resolve(model: Pick<ModelConfig, "provider"> | string): AIProvider;
+    list(): readonly AIProvider[];
+}
+export declare function createProviderRegistry(providers?: readonly AIProvider[]): ProviderRegistry;

package/dist/providers.js

@@ -0,0 +1,25 @@
+export function createProviderRegistry(providers = []) {
+    const byId = new Map();
+    const registry = {
+        register(provider) {
+            byId.set(provider.id, provider);
+        },
+        get(id) {
+            return byId.get(id);
+        },
+        resolve(model) {
+            const id = typeof model === "string" ? model : model.provider;
+            const provider = byId.get(id);
+            if (!provider)
+                throw new Error(`Unknown provider: ${id}`);
+            return provider;
+        },
+        list() {
+            return [...byId.values()];
+        },
+    };
+    for (const provider of providers)
+        registry.register(provider);
+    return registry;
+}
+//# sourceMappingURL=providers.js.map

package/dist/redaction.d.ts

@@ -0,0 +1,11 @@
+import type { AgentEvent, ErrorInfo, Message, ProviderRequest, SessionEntry } from "./contracts.js";
+export interface SecretRedactor {
+    redact<T>(value: T): T;
+}
+export declare function createSecretRedactor(secrets: readonly (string | undefined)[]): SecretRedactor;
+export declare function redactMessage(message: Message, redactor?: SecretRedactor): Message;
+export declare function redactAgentEvent(event: AgentEvent, redactor?: SecretRedactor): AgentEvent;
+export declare function redactSessionEntry(entry: SessionEntry, redactor?: SecretRedactor): SessionEntry;
+export declare function redactProviderRequest(request: ProviderRequest, redactor?: SecretRedactor): ProviderRequest;
+export declare function redactSecrets<T>(value: T, secrets: readonly (string | undefined)[]): T;
+export declare function errorToErrorInfo(error: unknown, secrets?: readonly (string | undefined)[]): ErrorInfo;