@arnilo/prism 0.0.1

package/docs/session-stores-and-branching.md

@@ -0,0 +1,119 @@
+# Session stores and branching
+
+## What it does
+
+Session store helpers define branch-aware session entries and pure utilities for creating entries, listing branch leaves, reading a leaf path, and rebuilding provider context from a selected leaf.
+
+Public helpers:
+
+- `createSessionEntry(options)`
+- `createMemorySessionStore(initialEntries?)`
+- `getSessionBranchEntries(entries, options)`
+- `listSessionBranches(entries)`
+- `rebuildSessionContext(entries, options)`
+
+## When to use it
+
+Use these helpers when a host, runtime session, or store adapter needs durable, branch-aware session data without coupling stores to providers, tools, credentials, or files.
+
+Do not use them as a database layer, migration system, lock service, compaction strategy, retry policy, CLI/RPC protocol, or hidden global store registry.
+
+## Inputs / request
+
+`SessionEntry` has stable branch fields plus typed payloads:
+
+| Field | Purpose |
+| --- | --- |
+| `id` | Unique entry id. |
+| `parentId` | Previous entry on the branch, if any. |
+| `sessionId` | Session that owns the entry. |
+| `timestamp` | ISO timestamp chosen by the caller/helper. |
+| `kind` | `message`, `event`, `summary`, `metadata`, `model_change`, `label`, `custom`, or `compaction`. |
+| `runId` | Optional run id. |
+| `message`, `event`, `model`, `previousModel`, `label`, `summary`, `data`, `metadata` | Optional payload fields for the entry kind. |
+
+`rebuildSessionContext()` and `getSessionBranchEntries()` accept an optional `leafId`. If omitted, the last entry is used as the leaf. `createMemorySessionStore()` accepts optional initial entries.
+
+## Outputs / response / events
+
+| Helper | Output |
+| --- | --- |
+| `createSessionEntry()` | A `SessionEntry` with generated `id` and `timestamp` when omitted. |
+| `getSessionBranchEntries()` | Ordered entries from root to selected leaf (deep copies). |
+| `listSessionBranches()` | Leaf ids and their root-to-leaf entry paths (deep copies). |
+| `rebuildSessionContext()` | `{ leafId, entries, messages, summaries }` for provider input rebuild; with a compaction entry, raw `entries` stay intact while `messages` becomes recent context and `summaries` includes the compaction summary. All arrays and objects are deep copies. |
+| `createMemorySessionStore()` | Async `SessionStore` with `append()`, `list(sessionId)`, and `get(id)`. `list()` and `get()` return deep copies. |
+
+Helpers throw on duplicate entry ids, unknown leaves, or missing parents. They do not mutate input arrays.
+
+For `kind: "compaction"`, `data` may contain `throughEntryId`, `keepEntryIds`, `strategy`, and `trigger`. The latest valid compaction entry on a branch is used as the provider-context boundary; raw history remains in `entries`.
+
+## Request/response example
+
+```json
+{
+  "leafId": "entry_2",
+  "messages": [{ "role": "user", "content": [{ "type": "text", "text": "Hi" }] }]
+}
+```
+
+## Implementation example
+
+```ts
+import { createMemorySessionStore, createSessionEntry, rebuildSessionContext } from "@arnilo/prism";
+
+const first = createSessionEntry({
+  id: "entry_1",
+  sessionId: "s1",
+  kind: "message",
+  message: { role: "user", content: [{ type: "text", text: "Hi" }] },
+});
+const label = createSessionEntry({
+  id: "entry_2",
+  parentId: first.id,
+  sessionId: "s1",
+  kind: "label",
+  label: "investigation",
+});
+
+const store = createMemorySessionStore([first]);
+await store.append(label);
+
+const context = rebuildSessionContext(await store.list("s1"), { leafId: label.id });
+```
+
+## Extension and configuration notes
+
+Stores and extensions can use these data helpers directly. Store adapters only need append/list/get behavior; branch queries are derived in memory from listed entries.
+
+`createMemorySessionStore()` is the built-in in-memory implementation. It preserves append order per session, isolates session ids, returns entries by id in O(1), rejects duplicate entry ids, and returns deep copies from `list()` and `get()`. It is process memory only; hosts that need durability should pass another `SessionStore`.
+
+`getSessionBranchEntries()` and `rebuildSessionContext()` also return deep copies of entries and messages, so callers cannot mutate the input arrays or the memory store by editing returned objects.
+
+`AgentSession` uses `AgentSessionConfig.store` before `AgentConfig.store`, otherwise a private memory store. It appends user, assistant, tool-result, and model-change entries, resumes from `leafId`, rebuilds provider history from the selected branch, checks out old leaves, forks by selecting a leaf in the same session, and clones the selected branch to a new session id.
+
+Node hosts that need simple file durability can import `createJsonlSessionStore()` from the explicit `@arnilo/prism/node/session-store-jsonl` subpath.
+
+Use `createDefaultCompactionStrategy()` to create compaction entries that `rebuildSessionContext()` understands. Compaction adds summaries; it does not delete or rewrite raw store entries.
+
+`createSessionEntry()` accepts injectable `createId` and `now` functions for deterministic tests or host id policy. Prism does not create a global store or id service.
+
+## Security and performance notes
+
+- Helpers are pure data functions: no provider calls, tool calls, settings reads, credential resolution, filesystem access, network access, timers, or dependencies.
+- Store only host-approved session entries. Do not put provider credentials, credential resolvers, provider objects, full provider requests, or secrets in entries.
+- Branch rebuild is linear over listed entries and uses `Map`, `Set`, and arrays only.
+- Compaction-aware rebuild keeps raw branch entries in `entries`; only provider-context `messages`/`summaries` are reduced.
+- Memory store lookup by id is O(1); list is O(n) for that session.
+- Duplicate ids and missing parents fail clearly instead of guessing a branch.
+
+## Related APIs
+
+- [Public contracts](public-contracts.md): `SessionEntry`, `SessionStore`, `StoreFactory`, and session contracts.
+- [Agent/session runtime](agent-session-runtime.md): runtime sessions use these branch helpers for store-backed history, checkout, fork, and clone.
+- [Node JSONL session store](node-jsonl-session-store.md): optional Node filesystem store for caller-named JSONL files.
+- [Compaction and retry policies](compaction-and-retry.md): default strategy for creating compaction entries.
+- [Input and prompt assembly](input-and-prompt-assembly.md): provider input assembly consumes rebuilt `messages` and `summaries`.
+- [Credentials and redaction](credentials-and-redaction.md): security boundary for secrets that must not enter session entries.
+
+Session stores persist the entries they receive. Configure `AgentConfig.redactor` or `RunOptions.redactor` before a run when known secrets must be removed before entries reach durable stores.

package/docs/settings-auth-trust-security.md

@@ -0,0 +1,73 @@
+# Settings, auth, trust, and security controls
+
+## What it does
+Prism exposes small host-owned helpers for settings, in-memory credentials, trust checks, permission checks, and exact known-secret redaction. It adds no hidden settings discovery, no hidden credential loading, no persistent secret store, does not auto-load project-local code, and no sandbox.
+
+## When to use it
+Use these APIs when a host wants one explicit place to compose settings, resolve caller-supplied credentials, deny untrusted resources/extensions/tools, or redact known secret strings before runtime serialization.
+
+## Inputs / request
+- `createStaticSettingsProvider(settings)` reads dotted keys from an in-memory JSON object.
+- `createChainedSettingsProvider(providers)` returns the first defined setting.
+- `createMemoryCredentialStore(initial?)` stores explicit credentials in memory only.
+- `createChainedCredentialResolver(resolvers)` returns the first credential found.
+- `createExplicitCredentialResolver(sources)` documents and applies named source order such as runtime override → stored → host env object → fallback.
+- `createEnvCredentialResolver(env, map)` reads only the caller-supplied object; it does not read `process.env`.
+- `assertTrusted(policy, request)` and `assertPermission(policy, request)` fail closed on denial.
+- `createSecretRedactor(secrets)` redacts exact known strings.
+- Node-only subpaths: `@arnilo/prism/node/settings` for caller-named JSON settings files and `@arnilo/prism/node/trust` for explicit trusted path roots with symlink-aware realpath checks.
+
+## Outputs / response / events
+Settings and credential helpers return existing `SettingsProvider` and `CredentialResolver` contracts. Permission denial blocks tool execution, extension setup, and resource loader calls before side effects. A configured `AgentConfig.redactor` or `RunOptions.redactor` redacts provider requests, emitted `AgentEvent` payloads, and stored `SessionEntry` values.
+
+## Request/response example
+```ts
+import { createSecretRedactor, createStaticPermissionPolicy, createStaticSettingsProvider } from "@arnilo/prism";
+
+const settings = createStaticSettingsProvider({ demo: { enabled: true } });
+const permission = createStaticPermissionPolicy({ allow: ["tool:echo:execute"] });
+const redactor = createSecretRedactor(["token-value"]);
+
+console.log(await settings.get("demo.enabled"));
+```
+
+## Implementation example
+```ts
+import { createAgent, createMemoryCredentialStore, createSecretRedactor, resolveCredentialValue } from "@arnilo/prism";
+import { loadSettingsFiles, defaultUserSettingsPath } from "@arnilo/prism/node/settings";
+import { createPathTrustPolicy } from "@arnilo/prism/node/trust";
+
+const settings = await loadSettingsFiles([
+  { name: "user", path: defaultUserSettingsPath(), optional: true },
+]);
+const credentials = createMemoryCredentialStore();
+credentials.set({ name: "api", provider: "demo", credential: { type: "api_key", value: "token-value" } });
+const trust = createPathTrustPolicy({ trustedRoots: [process.cwd()] });
+const apiKey = await resolveCredentialValue(credentials, { name: "api", provider: "demo" });
+
+const agent = createAgent({
+  model: { provider: "demo", model: "model" },
+  settings,
+  credentials,
+  redactor: apiKey ? createSecretRedactor([apiKey]) : undefined,
+});
+void trust;
+void agent;
+```
+
+## Extension and configuration notes
+Root imports stay filesystem-free. Node settings files are caller-named and read once; optional missing files are skipped. Trust storage, prompts, approval UI, OAuth token storage, environment-variable selection, and persistent credentials belong in the host or an extension package.
+
+## Security and performance notes
+Prism does not sandbox host tools or extensions. Prism does not read environment variables, keychains, user config files, package manifests, resources, or project-local extensions unless the host explicitly wires those operations. Redaction is exact known-secret replacement only; it is not secret detection. Permission and trust checks are one operation per guarded call and add no workers, watchers, retries, network, or filesystem scans.
+
+`@arnilo/prism/node/trust` resolves symlinks on both the trusted root and the target path. A path that is lexically inside a trusted root but escapes it through a symlink is rejected, and realpath failures (missing root, permission error) fail closed.
+
+## Related APIs
+- `createStaticSettingsProvider`, `createChainedSettingsProvider`
+- `createMemoryCredentialStore`, `createChainedCredentialResolver`, `createExplicitCredentialResolver`, `createEnvCredentialResolver`, `refreshOAuthCredential`, `resolveCredentialValue`
+- `createStaticTrustPolicy`, `assertTrusted`, `isTrusted`, `TrustDeniedError`
+- `createStaticPermissionPolicy`, `assertPermission`, `checkPermission`, `PermissionDeniedError`
+- `createSecretRedactor`, `redactMessage`, `redactAgentEvent`, `redactSessionEntry`, `redactProviderRequest`
+- `@arnilo/prism/node/settings`: `defaultUserSettingsPath`, `readSettingsFile`, `loadSettingsFiles`
+- `@arnilo/prism/node/trust`: `createPathTrustPolicy`, `isPathInside`, `isPathInsideReal`

package/docs/system-prompts.md

@@ -0,0 +1,116 @@
+# System prompts
+
+## What it does
+
+Layered system prompts let hosts compose caller-supplied prompt contributions before the default input builder turns them into system messages.
+
+Public helpers:
+
+- `composeSystemPrompt(contributions, { base })`
+- `mergeSystemPromptConfig(config, override)`
+- `SystemPromptContribution`, `SystemPromptMode`, `SystemPromptSource`, `SystemPromptConfig`
+
+`AgentConfig.instructions` stays the simple base prompt path. `AgentConfig.systemPrompt` and `RunOptions.systemPrompt` add explicit layers on top.
+
+## When to use it
+
+Use this API when an app wants deterministic package/app/user/run prompt layers without filesystem discovery or package loading.
+
+Do not use it for prompt template expansion, resource loading, settings discovery, credential lookup, provider calls, or hidden global prompts.
+
+## Inputs / request
+
+```ts
+composeSystemPrompt([
+  { id: "pkg", source: "package", mode: "append", text: "Package rule." },
+  { id: "app", source: "app", mode: "replace", text: "App rule." },
+  { id: "run", source: "run", mode: "append", text: "Run rule." },
+], { base: "Base instruction." });
+```
+
+`source` order is deterministic for known sources: `package`, `app`, `user`, then `run`. Unknown sources keep input order after known sources.
+
+`mode` behavior:
+
+| Mode | Behavior |
+| --- | --- |
+| `append` or omitted | Add text after earlier prompt text. |
+| `prepend` | Add text before current prompt text. |
+| `replace` | Clear earlier prompt text and use this text. |
+| `disable` | Clear earlier prompt text and add no text. Later layers may still add text. |
+
+`RunOptions.systemPrompt: false` disables configured prompt layers for that run while keeping `AgentConfig.instructions` as the base prompt.
+
+## Outputs / response / events
+
+`composeSystemPrompt()` returns the composed prompt string or `undefined` when no prompt text remains. The agent/session runtime passes that string to `assembleProviderInput()` as `systemInstructions`; it does not emit a separate event or store prompt layers.
+
+## Request/response example
+
+```json
+{
+  "base": "Base",
+  "layers": [
+    { "id": "app", "source": "app", "mode": "replace", "text": "App" },
+    { "id": "run", "source": "run", "mode": "append", "text": "Run" }
+  ],
+  "composed": "App\n\nRun"
+}
+```
+
+## Implementation example
+
+```ts
+import { composeSystemPrompt, createAgent } from "@arnilo/prism";
+
+const prompt = composeSystemPrompt([
+  { id: "app", source: "app", mode: "replace", text: "You are concise." },
+  { id: "user", source: "user", mode: "append", text: "Prefer bullet points." },
+], { base: "Base instruction." });
+
+const agent = createAgent({
+  model,
+  provider,
+  instructions: "Base instruction.",
+  systemPrompt: { id: "app", source: "app", mode: "append", text: "Use safe JSON." },
+});
+
+await agent.createSession().run("Hi", {
+  systemPrompt: { id: "run", source: "run", mode: "append", text: "Answer briefly." },
+});
+```
+
+## Extension and configuration notes
+
+Extensions and provider packages can register `SystemPromptContribution` values, but registration is inert. Hosts must select contributions and pass them to `AgentConfig.systemPrompt` or `RunOptions.systemPrompt`.
+
+Manifests can declare `systemPromptContribution` kinds as data-only references:
+
+```ts
+import { definePrismManifest } from "@arnilo/prism";
+
+export default definePrismManifest({
+  name: "demo-prompts",
+  contributions: [
+    { kind: "systemPromptContribution", name: "demo.prompt", metadata: { id: "demo-prompt", source: "package", mode: "append" } },
+  ],
+});
+```
+
+The manifest entry does not load or apply the prompt. The host must still select it and pass the `SystemPromptContribution` to the runtime.
+
+No `SYSTEM.md`, `APPEND_SYSTEM.md`, prompt template, settings, or manifest discovery happens in core.
+
+## Security and performance notes
+
+- Composition is a single in-memory pass plus deterministic ordering; no dependency, watcher, filesystem read, provider call, or tokenizer is added.
+- Prompt text is caller-supplied content. Do not put secrets in prompts, settings, manifests, session entries, package metadata, or docs examples.
+- `replace`/`disable` make prompt policy explicit; they are not permission or sandbox controls.
+
+## Related APIs
+
+- [Input and prompt assembly](input-and-prompt-assembly.md): default input builder receives the composed system instruction string.
+- [Agent/session runtime](agent-session-runtime.md): runtime fields `AgentConfig.systemPrompt` and `RunOptions.systemPrompt`.
+- [Contribution registries](contribution-registries.md): inert system prompt contribution registry.
+- [Extensions](extensions.md): `registerSystemPromptContribution()`.
+- [Public contracts](public-contracts.md): exported prompt contribution contracts.

package/docs/tools.md

@@ -0,0 +1,151 @@
+# Tools
+
+## What it does
+
+The tool harness gives hosts a small active registry, exact allow/deny filtering, and explicit dispatch for host-owned tools. Prism stores tool definitions and JSON Schema-compatible `parameters` metadata, but does not ship app tools, sandbox host code, or interpret schemas.
+
+APIs:
+
+- `createToolRegistry()` / `ToolRegistry`
+- `filterTools()`
+- `dispatchToolCall()`
+- `ToolFilter`, `ToolFilterInput`, `ToolValidator`, `DispatchToolCallOptions`
+
+## When to use it
+
+Use `createToolRegistry()` when a host has selected the tools that may be active for an agent, session, or run. Use `dispatchToolCall()` when provider output or host code requests one of those tools and the host wants Prism to enforce lookup, filtering, object arguments, validation, middleware order, and lifecycle events. `session.run()` uses these same primitives for its bounded tool loop.
+
+Do not use the harness as a sandbox, package loader, app-tool pack, permission policy engine, provider loop, or schema validator.
+
+## Inputs / request
+
+```ts
+createToolRegistry(tools?: readonly ToolDefinition[]): ToolRegistry
+filterTools(tools: readonly ToolDefinition[], filter?: ToolFilter | readonly ToolFilter[]): readonly ToolDefinition[]
+dispatchToolCall(options: DispatchToolCallOptions): Promise<ToolResult>
+```
+
+`ToolRegistry` methods:
+
+| Method | Input | Result |
+| --- | --- | --- |
+| `register(tool)` | `ToolDefinition` | Stores or replaces by `tool.name`. |
+| `get(name)` | tool name | Returns the tool or `undefined`. |
+| `resolve(name)` | tool name | Returns the tool or throws `Unknown tool: <name>`. |
+| `list()` | none | Returns tools in insertion order. |
+
+`ToolFilter` fields:
+
+| Field | Purpose |
+| --- | --- |
+| `allow` | Exact tool names allowed by this scope. Empty or missing means no allow restriction. |
+| `deny` | Exact tool names denied by this scope. Deny wins over allow. |
+
+When multiple filters are provided, each non-empty allow list must include the tool, and any deny list excludes it.
+
+`DispatchToolCallOptions` fields:
+
+| Field | Purpose |
+| --- | --- |
+| `call` | `ToolCallContent` to dispatch. Runtime checks still reject non-object arguments. |
+| `registry` | Active host `ToolRegistry`. |
+| `context` | `ToolExecutionContext` with session/run/tool call ids, signal, metadata, and optional progress callback. |
+| `filter` | Optional exact allow/deny filter or ordered filters. |
+| `middleware` | Optional `MiddlewareRegistry`; `tool_call` runs before validation/execution and `tool_result` runs after execution. |
+| `validate` | Optional host validator returning `void`, a message string, or `ErrorInfo`. |
+| `emit` | Optional `AgentEvent` callback for lifecycle events. |
+| `secrets` | Known secret values to redact from thrown tool errors. |
+
+## Outputs / response / events
+
+Registry calls return plain `ToolDefinition` objects. `resolve()` fails closed for unknown names before any tool can execute. Filtering returns only tools already present in the input list; it never creates or enables new tools.
+
+`dispatchToolCall()` returns a `ToolResult`. Unknown tools, denied tools, invalid arguments, validator failures, and thrown tool errors return a result with `error` and do not throw by default.
+
+Dispatch can emit these `AgentEvent` types:
+
+| Event | When |
+| --- | --- |
+| `tool_execution_blocked` | Unknown, denied, invalid-argument, or validator-blocked call. |
+| `tool_execution_started` | Immediately before `tool.execute()`. |
+| `tool_execution_progress` | When the tool calls `context.progress()`. |
+| `tool_execution_finished` | After successful execution and `tool_result` middleware. |
+| `tool_execution_error` | When `tool.execute()` throws. |
+
+## Request/response example
+
+```json
+{
+  "call": { "type": "tool_call", "id": "call_1", "name": "echo", "arguments": { "text": "hi" } },
+  "filter": { "allow": ["echo"] },
+  "result": { "toolCallId": "call_1", "name": "echo", "value": { "text": "hi" } }
+}
+```
+
+## Implementation example
+
+```ts
+import { createToolRegistry, dispatchToolCall, filterTools, type ToolDefinition } from "@arnilo/prism";
+
+const echo: ToolDefinition = {
+  name: "echo",
+  parameters: { type: "object", properties: { text: { type: "string" } } },
+  execute(args, context) {
+    return { toolCallId: context.toolCallId, name: "echo", value: args };
+  },
+};
+
+const registry = createToolRegistry([echo]);
+const active = filterTools(registry.list(), { allow: ["echo"] });
+
+const result = await dispatchToolCall({
+  call: { type: "tool_call", id: "call_1", name: "echo", arguments: { text: "hi" } },
+  registry,
+  context: { sessionId: "s1", runId: "r1", toolCallId: "call_1" },
+  filter: { allow: active.map((tool) => tool.name) },
+  validate: (_tool, args) => typeof args.text === "string" ? undefined : "text is required",
+});
+
+console.log(result.value);
+```
+
+## Extension and configuration notes
+
+Extensions can contribute tool definitions through `ExtensionAPI.registerTool()`, which stores them in `ContributionRegistries.tools`. Contributions are inert until the host explicitly selects/registers them in a tool registry and calls dispatch.
+
+```ts
+import { createContributionRegistries, createToolRegistry } from "@arnilo/prism";
+
+const contributions = createContributionRegistries();
+contributions.tools.register("echo", echo);
+
+const activeTools = createToolRegistry([contributions.tools.resolve("echo")]);
+```
+
+Middleware can transform `tool_call` and `tool_result` payloads, but dispatch re-checks active registry lookup, filters, and object arguments after `tool_call` middleware. Middleware cannot grant permission by changing a tool name.
+
+Configuration can carry allow/deny names, but Prism does not define a policy class or hidden global active tool set. Skills may reference `toolNames`, but `resolveActiveSkills()` only checks those names against the host-active tool list; it does not register, allow, or execute tools.
+
+## Security and performance notes
+
+- Tool lookup uses a `Map` for O(1) name lookup.
+- Filtering is exact-name matching over the provided tools and rules.
+- Unknown, denied, malformed, and validator-blocked calls fail closed.
+- Tool arguments must be JSON object-shaped before validation or execution.
+- `parameters` is pass-through metadata; hosts own schema interpretation and validation.
+- Prism does not sandbox host tools and does not include built-in app tools.
+- Contribution registration and registry/filter calls do not perform provider calls, credential resolution, resource loading, network, filesystem discovery, or tool execution.
+- Dispatch performs explicit in-memory checks and executes only the selected host-active tool; it adds no retries, queues, timers, or new dependencies.
+
+## Related APIs
+
+- [Agent/session runtime](agent-session-runtime.md): dispatches complete provider tool calls through the host-active tool harness and returns tool results on the next provider turn.
+- [Public contracts](public-contracts.md): `ToolDefinition`, `ToolRegistry`, `ToolExecutionContext`, `ToolResult`, and tool `AgentEvent` contracts.
+- [Contribution registries](contribution-registries.md): inert extension/package tool contribution storage.
+- [Extension kernel and event bus](extensions.md): `ExtensionAPI.registerTool()` contribution registration.
+- [Context and skills](context-and-skills.md): skill `toolNames` validation against host-active tools.
+- [Middleware hooks](middleware-hooks.md): `tool_call` and `tool_result` middleware used during dispatch.
+- [Credentials and redaction](credentials-and-redaction.md): redaction helpers used for tool execution errors.
+- [Observational memory compaction package](compaction-observational-memory.md): optional exact-id recall tool factory.
+
+`DispatchToolCallOptions.permission` can provide a `PermissionPolicy`; denial emits `tool_execution_blocked` before validation or `execute()`. Middleware cannot bypass this guard. Prism does not sandbox tools. See [Security/auth/trust](settings-auth-trust-security.md).

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@arnilo/prism",
+  "version": "0.0.1",
+  "description": "Agent harness for AI providers, agents, sessions, and tools.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./providers/openai-compatible": {
+      "types": "./dist/providers/openai-compatible.d.ts",
+      "default": "./dist/providers/openai-compatible.js"
+    },
+    "./testing/provider-conformance": {
+      "types": "./dist/testing/provider-conformance.d.ts",
+      "default": "./dist/testing/provider-conformance.js"
+    },
+    "./node/config": {
+      "types": "./dist/node/config.d.ts",
+      "default": "./dist/node/config.js"
+    },
+    "./node/settings": {
+      "types": "./dist/node/settings.d.ts",
+      "default": "./dist/node/settings.js"
+    },
+    "./node/trust": {
+      "types": "./dist/node/trust.d.ts",
+      "default": "./dist/node/trust.js"
+    },
+    "./node/session-store-jsonl": {
+      "types": "./dist/node/session-store-jsonl.d.ts",
+      "default": "./dist/node/session-store-jsonl.js"
+    }
+  },
+  "bin": {
+    "prism": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "docs",
+    "CHANGELOG.md"
+  ],
+  "workspaces": [
+    "packages/provider-*",
+    "packages/compaction-*",
+    "packages/prism-providers",
+    "packages/prism-compaction",
+    "packages/prism-all"
+  ],
+  "scripts": {
+    "build:core": "tsc",
+    "build": "npm run build:core && npm run build --workspaces --if-present",
+    "typecheck": "npm run build:core && npm run typecheck --workspaces --if-present && tsc -p examples --noEmit",
+    "test": "npm run build && node --test dist/__tests__/*.test.js && npm run test --workspaces --if-present",
+    "pack:dry-run": "npm pack --dry-run && npm run pack:dry-run --workspaces --if-present",
+    "release:dry-run": "npm test && npm run pack:dry-run"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism#readme",
+  "keywords": [
+    "prism",
+    "agent",
+    "llm",
+    "ai",
+    "framework",
+    "chatbot"
+  ],
+  "sideEffects": [
+    "dist/cli.js"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}