@arnilo/prism 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Added `LICENSE` (MIT) and `CHANGELOG.md` to the published `prism` package.
+- Added npm package metadata: `license`, `repository`, `bugs`, `homepage`,
+  `keywords`, and `sideEffects`.
+
+### Changed
+
+- `files` whitelist now explicitly excludes `dist/__tests__/` and
+  `dist/**/*.map` from published tarballs; source maps remain emitted locally
+  for debugging but are no longer shipped.
+- Core tarball now ships the `/docs` hub.
+- Made `prism` a required peer dependency for all first-party workspace packages; it is no longer optional. The peer range remains `0.0.1` and will widen to `^1.0.0` at the 1.x stable release.
+- Pinned the no-network `npm test` budget at < 30s on Node 20 (measured baseline ~22s); recorded in `roadmap.md` Phase 17.
+
+## [0.0.1] - 2026-06-22
+
+### Added
+
+- Initial release of Prism: a framework for building agentic LLM applications
+  with configurable providers, sessions, tools, context providers, compaction,
+  extensions, and trust boundaries.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# prism
+
+`prism` is a TypeScript/Node.js agent harness. Host apps and extension packages
+bring their tools, providers, credentials, storage, and UI; Prism supplies the
+common contracts, registries, agent/session runtime, replaceable input/prompt
+and compaction strategies, CLI/RPC adapters, and first-party provider/compaction
+packages. Prism defines contracts, not apps.
+
+## Current scope
+
+- **Agent/session runtime**: `createAgent`/`createAgentSession`, run prompts,
+  dispatch host tools, subscribe to normalized `AgentEvent` streams, abort runs,
+  compact, and navigate branches.
+- **Providers and models**: provider/model registries, provider event helpers,
+  credential redaction helpers, mock provider, and an optional
+  OpenAI-compatible provider subpath.
+- **First-party packages**: `@arnilo/prism-provider-openai`, `@arnilo/prism-provider-opencode-go`,
+  `@arnilo/prism-provider-openrouter`, `@arnilo/prism-provider-zai`, `@arnilo/prism-provider-kimi`,
+  `@arnilo/prism-compaction-llm`, and `@arnilo/prism-compaction-observational-memory`.
+- **Tools, context, skills**: host-owned tool registry with allow/deny filtering
+  and dispatch, context providers, and a skill registry with progressive
+  disclosure.
+- **Input/prompt/context**: default input and prompt builders, system-prompt
+  layering, and provider-input assembly — every stage replaceable.
+- **Sessions and memory**: in-memory and JSONL session stores, branching/fork/
+  clone, default and LLM compaction strategies, retry policy, and
+  observational-memory recall/status/view.
+- **Extensions and manifests**: extension kernel + event bus, contribution
+  registries, middleware hooks, and data-only package manifests.
+- **Config, settings, security**: layered config merge, settings providers,
+  credential resolvers, trust/permission policies, and secret redaction.
+- **CLI/RPC**: `prism --mode print|json|rpc` over the same `AgentSession` API.
+
+## Install
+
+```bash
+npm install @arnilo/prism
+```
+
+First-party provider/compaction packages are separate installs and require
+`@arnilo/prism` as a non-optional peer. Install a single package, or use an
+umbrella to grab a whole family in one line:
+
+```bash
+npm install @arnilo/prism @arnilo/prism-provider-openai   # core + one provider
+npm install @arnilo/prism @arnilo/prism-providers          # core + all providers
+npm install @arnilo/prism-all                               # everything
+```
+
+See [docs/release-and-install.md](docs/release-and-install.md) for install
+specifiers, tarball contents, and the offline test budget.
+
+## Quick start
+
+```ts
+import { createAgent, createAgentSession, createMockProvider } from "@arnilo/prism";
+
+// Host owns the provider. createMockProvider is for tests/demos only.
+const agent = createAgent({
+  model: { provider: "mock", model: "demo" },
+  provider: createMockProvider([{ type: "text", text: "Hello" }, { type: "done" }]),
+});
+
+const session = createAgentSession({ agent });
+
+(async () => {
+  for await (const event of session.subscribe()) {
+    // AgentEvent: agent_started, message_delta, turn_finished, ...
+  }
+  await session.run("Hi");
+})();
+```
+
+Register a first-party provider package through the extension kernel:
+
+```ts
+import { createExtensionKernel, createEnvCredentialResolver } from "@arnilo/prism";
+import { createOpenAIProviderPackage } from "@arnilo/prism-provider-openai";
+
+const kernel = createExtensionKernel();
+await kernel.load([
+  createOpenAIProviderPackage({
+    apiKey: createEnvCredentialResolver({ OPENAI_API_KEY: "fake" }, { openai: "OPENAI_API_KEY" }),
+  }),
+]);
+```
+
+Hosts own credentials. Do not put secrets in prompts, messages, events, stores,
+or logs. Prism never reads `process.env` on its own; credential resolvers are
+caller-supplied.
+
+## CLI
+
+```bash
+prism --provider mock --model demo -p "Hi"          # print mode (default)
+prism --provider mock --mode json -p "Hi"            # one event envelope per line
+printf '{"id":"1","command":"prompt","params":{"input":"Hi"}}\n' \
+  | prism --provider mock --mode rpc                 # LF-delimited JSONL RPC
+```
+
+## Docs
+
+- [docs/index.md](docs/index.md) — navigational map of every public surface.
+- The `examples/` directory holds compile-checked typed examples and runnable
+  mock demos (provider registration, auth, tools, stores/branching, compaction,
+  observational-memory recall, CLI, RPC).
+
+## Packages
+
+| package | purpose |
+|---------|---------|
+| `@arnilo/prism` | core contracts, runtime, registries, CLI/RPC |
+| `@arnilo/prism-provider-openai` | OpenAI Responses + Codex OAuth provider |
+| `@arnilo/prism-provider-opencode-go` | OpenCode Go provider |
+| `@arnilo/prism-provider-openrouter` | OpenRouter provider with per-model cache control |
+| `@arnilo/prism-provider-zai` | ZAI GLM provider |
+| `@arnilo/prism-provider-kimi` | Kimi For Coding provider |
+| `@arnilo/prism-compaction-llm` | provider-backed compaction strategy |
+| `@arnilo/prism-compaction-observational-memory` | source-backed memory + recall tool |
+| `@arnilo/prism-providers` | umbrella: all 5 provider adapters |
+| `@arnilo/prism-compaction` | umbrella: both compaction strategies |
+| `@arnilo/prism-all` | umbrella: core + providers + compaction |
+
+## Scripts
+
+| command | action |
+|---------|--------|
+| `npm run build` | Compile TypeScript to `dist/` (core + workspaces) |
+| `npm run typecheck` | Type-check without emitting |
+| `npm test` | Build + run network-free tests |
+| `prism --help` | CLI help |
+
+## Non-goals (v1)
+
+- Built-in shell/filesystem/browser tools — ship as separate packages only.
+- MCP bridge — external extension package after extension APIs settle.
+- TUI or interactive terminal — CLI/RPC only in core.
+- Workflow/graph orchestration — bounded agent loops first.
+- Encrypted/keychain credential storage — host-owned until a real app needs it.

package/dist/agents.d.ts

@@ -0,0 +1,5 @@
+import type { Agent, AgentConfig, AgentSession, AgentSessionConfig } from "./contracts.js";
+export declare function createAgent(config: AgentConfig): Agent;
+export declare function createAgentSession(config: AgentSessionConfig & {
+    readonly agent: Agent;
+}): AgentSession;

package/dist/agents.js

@@ -0,0 +1,439 @@
+import { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
+import { assembleProviderInput } from "./input.js";
+import { createProviderRequestPolicyChain, mergeProviderRequestOptions, normalizeProviderRequestPolicyResult } from "./provider-request-policy.js";
+import { errorToErrorInfo, redactAgentEvent, redactProviderRequest, redactSecrets, redactSessionEntry } from "./redaction.js";
+import { composeSystemPrompt, mergeSystemPromptConfig } from "./system-prompts.js";
+import { createDefaultRetryPolicy, waitForRetry } from "./retry.js";
+import { createMemorySessionStore, createSessionEntry, getSessionBranchEntries, rebuildSessionContext } from "./session-stores.js";
+import { createToolRegistry, dispatchToolCall } from "./tools.js";
+export function createAgent(config) {
+    return {
+        config,
+        createSession(sessionConfig = {}) {
+            return createAgentSession({ ...sessionConfig, agent: this });
+        },
+    };
+}
+export function createAgentSession(config) {
+    return new RuntimeAgentSession(config);
+}
+class RuntimeAgentSession {
+    id;
+    agent;
+    metadata;
+    store;
+    subscribers = new Set();
+    currentLeafId;
+    history = [];
+    activeRun;
+    activeRedactor;
+    constructor(config) {
+        this.id = config.id ?? randomId("session");
+        this.agent = config.agent;
+        this.metadata = config.metadata;
+        this.store = config.store ?? config.agent.config.store ?? createMemorySessionStore();
+        this.currentLeafId = config.leafId;
+    }
+    subscribe() {
+        const subscriber = new EventSubscriber(() => this.subscribers.delete(subscriber));
+        this.subscribers.add(subscriber);
+        return subscriber;
+    }
+    async run(input, options = {}) {
+        const runId = randomId("run");
+        if (this.activeRun) {
+            const error = new Error("Agent session already has an active run");
+            this.emit({ type: "error", sessionId: this.id, runId, error: errorToErrorInfo(error) });
+            throw error;
+        }
+        let usage;
+        const controller = new AbortController();
+        const cleanupSignal = bridgeAbort(options.signal, controller);
+        this.activeRun = controller;
+        this.activeRedactor = options.redactor ?? this.agent.config.redactor;
+        try {
+            this.requireProvider();
+            throwIfAborted(controller.signal);
+            this.emit({ type: "agent_started", sessionId: this.id, runId });
+            await this.rebuildHistory();
+            if (options.model && JSON.stringify(options.model) !== JSON.stringify(this.agent.config.model)) {
+                await this.appendEntry(createSessionEntry({ sessionId: this.id, parentId: this.currentLeafId, runId, kind: "model_change", previousModel: this.agent.config.model, model: options.model }));
+            }
+            const inputMessages = inputToMessages(input).map((message) => this.redact(message));
+            for (const message of inputMessages)
+                await this.appendMessage(message, runId);
+            await this.autoCompact(runId, options, controller.signal, inputMessages);
+            const metadata = { ...this.agent.config.metadata, ...this.metadata, ...options.metadata };
+            const { registry, tools } = activeTools(this.agent.config.tools);
+            const maxToolRounds = options.maxToolRounds ?? 1;
+            const toolResults = [];
+            let toolRounds = 0;
+            let nextInput = input;
+            for (let turn = 1;; turn += 1) {
+                throwIfAborted(controller.signal);
+                this.emit({ type: "turn_started", sessionId: this.id, runId, turn });
+                const request = await assembleProviderInput({
+                    model: options.model ?? this.agent.config.model,
+                    input: nextInput,
+                    history: this.history,
+                    summaries: (await this.snapshot()).summaries,
+                    toolResults,
+                    systemInstructions: composeSystemPrompt(mergeSystemPromptConfig(this.agent.config.systemPrompt, options.systemPrompt), { base: this.agent.config.instructions }),
+                    inputBuilder: this.agent.config.inputBuilder,
+                    promptBuilder: this.agent.config.promptBuilder,
+                    contextProviders: this.agent.config.context,
+                    skills: this.agent.config.skills ? ("list" in this.agent.config.skills ? this.agent.config.skills.list() : this.agent.config.skills) : undefined,
+                    tools,
+                    resourceLoader: this.agent.config.resourceLoader,
+                    providerOptions: mergeProviderRequestOptions(this.agent.config.providerOptions, options.providerOptions),
+                    middleware: this.agent.config.middleware,
+                    sessionId: this.id,
+                    runId,
+                    metadata,
+                    signal: controller.signal,
+                });
+                throwIfAborted(controller.signal);
+                const policyResult = await this.applyProviderRequestPolicies(request, runId, options, metadata, controller.signal);
+                const middlewareRequest = await this.agent.config.middleware?.run("provider_request", policyResult.request) ?? policyResult.request;
+                const { content, calls, messageId, started, usage: turnUsage } = await this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets);
+                usage = turnUsage ?? usage;
+                if (turn === 1)
+                    this.history.push(...inputMessages);
+                if (started) {
+                    const message = { id: messageId, role: "assistant", content };
+                    this.history.push(message);
+                    await this.appendMessage(message, runId);
+                    this.emit({ type: "message_finished", sessionId: this.id, runId, message });
+                }
+                this.emit({ type: "turn_finished", sessionId: this.id, runId, turn });
+                if (calls.length === 0 || toolRounds >= maxToolRounds)
+                    break;
+                toolRounds += 1;
+                for (const call of calls) {
+                    const result = await dispatchToolCall({
+                        call,
+                        registry,
+                        context: { sessionId: this.id, runId, toolCallId: call.id, signal: controller.signal, metadata },
+                        middleware: this.agent.config.middleware,
+                        emit: (event) => this.emit(event),
+                        permission: this.agent.config.permission,
+                        redactor: this.activeRedactor,
+                    });
+                    toolResults.push(result);
+                    await this.appendMessage(toolResultMessage(result), runId);
+                    throwIfAborted(controller.signal);
+                }
+                nextInput = [];
+            }
+            this.emit({ type: "agent_finished", sessionId: this.id, runId, usage });
+        }
+        catch (error) {
+            const info = errorToErrorInfo(error);
+            this.emit({ type: "error", sessionId: this.id, runId, error: info });
+            throw error;
+        }
+        finally {
+            if (this.activeRun === controller)
+                this.activeRun = undefined;
+            this.activeRedactor = undefined;
+            cleanupSignal();
+            this.closeSubscribers();
+        }
+    }
+    prompt(input, options) {
+        return this.run(input, options);
+    }
+    async compact(options = {}) {
+        if (this.activeRun)
+            throw new Error("Agent session already has an active run");
+        return this.compactBranch(options, undefined, options.signal, "manual");
+    }
+    abort(reason) {
+        this.activeRun?.abort(reason);
+    }
+    async entries() {
+        return getSessionBranchEntries(await this.store.list(this.id), { leafId: this.currentLeafId });
+    }
+    async checkout(leafId) {
+        this.currentLeafId = leafId;
+        await this.rebuildHistory();
+    }
+    fork(options = {}) {
+        return createAgentSession({ agent: this.agent, id: this.id, store: this.store, leafId: options.leafId ?? this.currentLeafId, metadata: this.metadata });
+    }
+    async clone(options = {}) {
+        const id = options.id ?? randomId("session");
+        const branch = getSessionBranchEntries(await this.store.list(this.id), { leafId: options.leafId ?? this.currentLeafId });
+        const remap = new Map();
+        for (const entry of branch) {
+            const nextId = randomId("entry");
+            remap.set(entry.id, nextId);
+            const { id: _oldId, parentId: _oldParentId, sessionId: _oldSessionId, ...rest } = entry;
+            await this.store.append({ ...rest, id: nextId, parentId: entry.parentId ? remap.get(entry.parentId) : undefined, sessionId: id });
+        }
+        return createAgentSession({ agent: this.agent, id, store: this.store, leafId: branch.length ? remap.get(branch[branch.length - 1].id) : undefined, metadata: this.metadata });
+    }
+    requireProvider() {
+        if (!this.agent.config.provider)
+            throw new Error(`Unknown provider: ${this.agent.config.model.provider}`);
+    }
+    emit(event) {
+        const redacted = redactAgentEvent(event, this.activeRedactor);
+        for (const subscriber of this.subscribers)
+            subscriber.push(redacted);
+    }
+    closeSubscribers() {
+        for (const subscriber of this.subscribers)
+            subscriber.close();
+        this.subscribers.clear();
+    }
+    async generateWithRetry(request, runId, options, signal, requestSecrets = []) {
+        const retry = mergeRetry(this.agent.config.retry, options.retry);
+        const secrets = [...requestSecrets, ...(retry?.secrets ?? [])];
+        const policy = retry?.policy ?? (retry ? createDefaultRetryPolicy(retry) : undefined);
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                return await this.generateProviderTurn(request, runId, signal, secrets);
+            }
+            catch (error) {
+                const failure = error instanceof ProviderTurnFailure ? error : undefined;
+                const info = failure ? redactSecrets(failure.info, secrets) : errorToErrorInfo(error, secrets);
+                if (!policy || failure?.observable)
+                    throw errorFromInfo(info);
+                const context = { sessionId: this.id, runId, attempt, error: info, metadata: retry?.metadata, signal };
+                let decision = await policy.decide(context);
+                const payload = await this.agent.config.middleware?.run("retry", { context, decision }) ?? { context, decision };
+                decision = payload.decision;
+                if (!decision.retry)
+                    throw errorFromInfo(info);
+                const delayMs = decision.delayMs ?? 0;
+                this.emit({ type: "retry_scheduled", sessionId: this.id, runId, attempt, delayMs, error: info });
+                await waitForRetry(decision, signal);
+            }
+        }
+    }
+    async generateProviderTurn(request, runId, signal, secrets = []) {
+        const content = [];
+        const calls = [];
+        let messageId;
+        let started = false;
+        let usage;
+        try {
+            for await (const event of this.agent.config.provider.generate(request)) {
+                throwIfAborted(signal);
+                if (event.type === "error")
+                    throw new ProviderTurnFailure(event.error, started);
+                if (event.type === "usage")
+                    usage = event.usage;
+                if (event.type === "done") {
+                    usage = event.usage ?? usage;
+                    break;
+                }
+                if (event.type === "message_start") {
+                    started = true;
+                    messageId = event.messageId;
+                    this.emit({ type: "message_started", sessionId: this.id, runId, message: { id: messageId, role: "assistant", content: [] } });
+                    continue;
+                }
+                if (event.type === "content_delta" || event.type === "tool_call") {
+                    if (!started) {
+                        started = true;
+                        this.emit({ type: "message_started", sessionId: this.id, runId, message: { role: "assistant", content: [] } });
+                    }
+                    const block = providerContent(event);
+                    content.push(block);
+                    if (block.type === "tool_call")
+                        calls.push(block);
+                    this.emit({ type: "message_delta", sessionId: this.id, runId, content: block });
+                }
+            }
+            return { content, calls, messageId, started, usage };
+        }
+        catch (error) {
+            if (error instanceof ProviderTurnFailure)
+                throw error;
+            throw new ProviderTurnFailure(errorToErrorInfo(error, secrets), started);
+        }
+    }
+    async applyProviderRequestPolicies(request, runId, options, metadata, signal) {
+        const policies = [...policyList(this.agent.config.providerRequestPolicies), ...policyList(options.providerRequestPolicies)];
+        if (policies.length === 0)
+            return { request, secrets: [] };
+        const result = await createProviderRequestPolicyChain(policies).apply({ request, sessionId: this.id, runId, metadata, signal });
+        return normalizeProviderRequestPolicyResult(result);
+    }
+    async appendMessage(message, runId) {
+        await this.appendEntry(createSessionEntry({ sessionId: this.id, parentId: this.currentLeafId, runId, kind: "message", message }));
+    }
+    async autoCompact(runId, options, signal, inputMessages) {
+        const compaction = mergeCompaction(this.agent.config.compaction, options.compaction);
+        if (!compaction || compaction.thresholdEntries === undefined)
+            return;
+        const snapshot = await this.snapshot();
+        if (snapshot.entries.length <= compaction.thresholdEntries || snapshot.entries.at(-1)?.kind === "compaction")
+            return;
+        await this.compactBranch(compaction, runId, signal, "auto");
+        const compacted = await this.snapshot();
+        this.history = withoutTrailingInput(compacted.messages, inputMessages);
+    }
+    async compactBranch(options, runId, signal, trigger) {
+        throwIfAbortedSignal(signal);
+        const entries = await this.entries();
+        const secrets = options.secrets ?? [];
+        const strategy = options.strategy ?? createDefaultCompactionStrategy({ keepRecentEntries: options.keepRecentEntries, maxSummaryChars: options.maxSummaryChars, secrets });
+        const context = { sessionId: this.id, entries, keepRecentEntries: options.keepRecentEntries, trigger, secrets, metadata: options.metadata, signal };
+        this.emit({ type: "compaction_started", sessionId: this.id, runId });
+        let result = await strategy.compact(context);
+        result = { ...result, summary: redactSecrets(result.summary, secrets) };
+        const payload = await this.agent.config.middleware?.run("compaction", { context, result }) ?? { context, result };
+        result = { ...payload.result, summary: redactSecrets(payload.result.summary, secrets) };
+        const source = result.entries?.find((entry) => entry.kind === "compaction");
+        const data = isCompactionEntryData(source?.data) ? source.data : undefined;
+        const entry = createSessionEntry({ sessionId: this.id, parentId: this.currentLeafId, runId, kind: "compaction", summary: result.summary, data });
+        await this.appendEntry(entry);
+        const finalResult = { ...result, entries: [entry] };
+        this.emit({ type: "compaction_finished", sessionId: this.id, runId, summary: finalResult.summary });
+        await this.rebuildHistory();
+        return finalResult;
+    }
+    async appendEntry(entry) {
+        const redacted = redactSessionEntry(entry, this.activeRedactor);
+        await this.store.append(redacted);
+        this.currentLeafId = redacted.id;
+    }
+    redact(value) {
+        return this.activeRedactor?.redact(value) ?? value;
+    }
+    redactProviderRequest(request) {
+        return redactProviderRequest(request, this.activeRedactor);
+    }
+    async rebuildHistory() {
+        this.history = (await this.snapshot()).messages.slice();
+    }
+    async snapshot() {
+        return rebuildSessionContext(await this.store.list(this.id), { leafId: this.currentLeafId });
+    }
+}
+class EventSubscriber {
+    onClose;
+    queue = [];
+    waiters = [];
+    closed = false;
+    constructor(onClose) {
+        this.onClose = onClose;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    next() {
+        const event = this.queue.shift();
+        if (event)
+            return Promise.resolve({ value: event, done: false });
+        if (this.closed)
+            return Promise.resolve({ value: undefined, done: true });
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    return() {
+        this.close();
+        this.onClose();
+        return Promise.resolve({ value: undefined, done: true });
+    }
+    push(event) {
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter({ value: event, done: false });
+        else if (!this.closed)
+            this.queue.push(event);
+    }
+    close() {
+        this.closed = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter({ value: undefined, done: true });
+    }
+}
+function providerContent(event) {
+    return event.type === "content_delta" ? event.content : event.call;
+}
+function inputToMessages(input) {
+    if (typeof input === "string")
+        return [{ role: "user", content: [{ type: "text", text: input }] }];
+    if ("role" in input)
+        return [input];
+    return [...input];
+}
+function toolResultMessage(result) {
+    return {
+        role: "tool",
+        content: [{ type: "tool_result", toolCallId: result.toolCallId, name: result.name, result: result.value, error: result.error }, ...(result.content ?? [])],
+        metadata: result.metadata,
+    };
+}
+function activeTools(tools) {
+    if (!tools)
+        return { registry: createToolRegistry(), tools: [] };
+    if ("list" in tools)
+        return { registry: tools, tools: tools.list() };
+    const registry = createToolRegistry(tools);
+    return { registry, tools };
+}
+function policyList(policies) {
+    if (!policies)
+        return [];
+    return "apply" in policies ? [policies] : policies;
+}
+function errorFromInfo(error) {
+    return Object.assign(new Error(error.message), { name: error.name ?? "Error", cause: error.cause });
+}
+class ProviderTurnFailure extends Error {
+    info;
+    observable;
+    constructor(info, observable) {
+        super(info.message);
+        this.info = info;
+        this.observable = observable;
+    }
+}
+function mergeRetry(agent, run) {
+    if (run === false)
+        return undefined;
+    if (run)
+        return { ...(agent || {}), ...run };
+    return agent || undefined;
+}
+function mergeCompaction(agent, run) {
+    if (run === false)
+        return undefined;
+    if (run)
+        return { ...(agent || {}), ...run };
+    return agent || undefined;
+}
+function withoutTrailingInput(messages, input) {
+    const next = [...messages];
+    for (let i = input.length - 1; i >= 0; i -= 1) {
+        const last = next.at(-1);
+        if (last && JSON.stringify(last) === JSON.stringify(input[i]))
+            next.pop();
+    }
+    return next;
+}
+function bridgeAbort(signal, controller) {
+    if (!signal)
+        return () => undefined;
+    const abort = () => controller.abort(signal.reason);
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener("abort", abort, { once: true });
+    return () => signal.removeEventListener("abort", abort);
+}
+function throwIfAborted(signal) {
+    throwIfAbortedSignal(signal);
+}
+function throwIfAbortedSignal(signal) {
+    if (signal?.aborted)
+        throw signal.reason instanceof Error ? signal.reason : new Error("Agent run aborted");
+}
+function randomId(prefix) {
+    return `${prefix}_${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
+}
+//# sourceMappingURL=agents.js.map

package/dist/cli-runner.d.ts

@@ -0,0 +1,33 @@
+import type { Readable, Writable } from "node:stream";
+import type { AgentSession } from "./contracts.js";
+import { type RpcSessionFactory } from "./rpc.js";
+export type CliMode = "print" | "json" | "rpc";
+export interface CliOptions {
+    readonly mode: CliMode;
+    readonly prompt?: string;
+    readonly provider?: string;
+    readonly model?: string;
+    readonly session?: string;
+    readonly config: readonly string[];
+    readonly resources: readonly string[];
+    readonly extensions: readonly string[];
+    readonly tools: readonly string[];
+    readonly system?: string;
+    readonly context: readonly string[];
+    readonly compact?: number;
+    readonly maxToolRounds?: number;
+    readonly help: boolean;
+}
+export interface CliRuntime {
+    readonly stdin: Readable;
+    readonly stdout: Writable;
+    readonly stderr: Writable;
+    readonly createSession?: (options: CliOptions) => AgentSession;
+    readonly commands?: RpcSessionFactory["commands"];
+}
+export declare const usage = "Usage: prism [--mode print|json|rpc] [-p prompt] [options]\n\nOptions:\n  -p, --prompt <text>        Prompt to run in print/json mode\n  --provider <name>          Explicit provider id (mock is built in for smoke tests)\n  --model <name>             Explicit model name\n  --session <id>             Session id\n  --config <path>            Explicit config path (recorded, not auto-loaded)\n  --resource <uri>           Explicit resource URI (recorded, not auto-loaded)\n  --extension <name>         Explicit extension name (recorded, not auto-loaded)\n  --tool <name>              Explicit tool name (recorded, not auto-enabled)\n  --system <text>            System instructions\n  --context <text>           Context text\n  --compact <entries>        Auto-compaction threshold\n  --max-tool-rounds <n>      Maximum tool rounds\n  -h, --help                 Show this help\n";
+export declare function parseCliArgs(argv: readonly string[]): CliOptions;
+export declare function runCli(argv: readonly string[], runtime: CliRuntime): Promise<number>;
+export declare function runPromptMode(session: AgentSession, options: CliOptions, stdout: Writable, mode: "print" | "json"): Promise<void>;
+export declare class CliUsageError extends Error {
+}