@arnilo/prism 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -7,6 +7,46 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.5] - 2026-07-16
+
+- `@arnilo/prism-providers` now installs all seven first-party adapters including AI SDK interoperability; `@arnilo/prism-all` now installs every first-party package while activating none automatically.
+
+- Added optional `@arnilo/prism-supervisor` with bounded explicit child delegation, derived memory scope IDs, narrowing-only permissions, A2A 1.0 cards/ES256 signatures, authorized JSON-RPC/SSE serving, and an exact-origin remote client.
+
+- Added bounded immutable run/trace feedback with exact ownership, evaluation linkage, memory/SQLite/PostgreSQL stores, schema migration 003, and safe OpenTelemetry projection.
+
+- Phase 11 extends workflows with explicit durable schedules/background execution, nested composition, bounded validated state, immutable-lineage replay, and optional command/Web bindings over existing checkpoint/lease primitives.
+
+- Optional `@arnilo/prism-server` package with authorized bounded Web-standard direct/SSE agent and durable workflow routes; `@arnilo/prism-mcp` now supports explicit authorized Prism tool/command server exposure and bounded Web-standard Streamable HTTP handling.
+- Optional `@arnilo/prism-rag` package: bounded deterministic text/Markdown chunking, Phase 7 vector indexing/retrieval, stable citations, metadata filters, redaction, and explicit ContextProvider injection.
+- Workflows now support durable human `suspend()`/approve/deny, expected-version exact-once resume, validated/redacted resume payloads, and opt-in tool approval with execution-policy recheck.
+
+### Added
+
+- Optional `@arnilo/prism-memory` package: schema/template-backed working memory, semantic recall, package-owned `Embedder`/`VectorStore` contracts, in-memory adapters, context provider, opt-in processor, shared conformance, and PostgreSQL/pgvector production path.
+
+## [0.0.4] - 2026-07-14
+
+### Added
+
+- Shared bounded provider transport, OpenAI serialization/media helpers, native structured-output contracts, provider/tool timing metadata, and audio/file/document content capability checks.
+- Generic checkpoint, atomic lease, and bounded event-multiplexer contracts plus persistence/run-ledger conformance helpers.
+- Optional packages for JSON Schema tool validation, MCP, coding approval/sandboxing, OpenTelemetry, encrypted/keychain credentials, SQLite/PostgreSQL persistence, and bounded workflow orchestration.
+- Manifest-only `base`, `code`, and `sdk` profiles; `prism-all` now transitively installs every first-party package.
+- Workflow, multimodal, persistence/resume, provider telemetry, cache, and external-adapter examples.
+
+### Changed
+
+- Single-shot loops support ordered bounded parallel tools; `ToolDefinition.exclusive` serializes dangerous turns without reducing later concurrency.
+- Provider requests, SSE/error bodies, media, schemas, event queues, checkpoints, and workflow fan-out/output use documented finite limits.
+- Session/ledger writes preserve order and redact before persistence; revision-loop transcript ordering and OAuth abort polling are hardened.
+- All first-party providers use shared bounded transport helpers and expose current structured-output, multimodal, caching, reasoning, telemetry, and retry behavior where supported.
+
+### Security
+
+- Added fail-closed schema/prototype-pollution, SSRF/media, SQL/tenant, path/shell approval, MCP result, credential-envelope, OAuth, redaction, and stale-worker fencing coverage.
+- Optional privileged capabilities remain inactive until hosts explicitly register transports/tools, configure roots/credentials/databases, and approve execution.
+
 ## [0.0.3] - 2026-07-08
 
 ### Added

package/README.md

@@ -17,23 +17,23 @@ packages. Prism defines contracts, not apps.
   OpenAI/OpenRouter use best-effort explicit cache hints, NeuralWatt uses
   best-effort implicit prefix caching, and other providers have route/model-specific
   or no cache-control support; see [docs/provider-caching.md](docs/provider-caching.md).
-- **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-provider-neuralwatt`, `@arnilo/prism-compaction-llm`, and
-  `@arnilo/prism-compaction-observational-memory`.
+- **First-party packages**: six provider adapters, two compaction strategies,
+  coding tools/security, JSON Schema validation, MCP, workflows, OpenTelemetry,
+  encrypted credentials, SQLite/PostgreSQL persistence, and manifest-only install profiles.
 - **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.
+  clone, default and LLM compaction strategies, retry policy,
+  observational-memory recall/status/view, optional working/semantic memory
+  (`@arnilo/prism-memory`), and bounded text/Markdown RAG (`@arnilo/prism-rag`).
 - **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.
+- **CLI/RPC/server**: `prism --mode print|json|rpc`, `prism init`, optional framework-free authorized Web agent/workflow routes, and explicit MCP server exposure.
 
 ## Install
 
@@ -41,14 +41,18 @@ packages. Prism defines contracts, not apps.
 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:
+First-party code packages are separate imports and require `@arnilo/prism` as
+a non-optional peer. Install atomic packages directly or choose a manifest-only
+family/profile; profiles install packages but expose no alias exports and activate nothing:
 
 ```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
+npm install @arnilo/prism @arnilo/prism-provider-openai    # core + one provider
+npm install @arnilo/prism-base                              # core + compaction + validation
+npm install @arnilo/prism-code @arnilo/prism-provider-openai # coding-agent profile
+npm install @arnilo/prism-sdk @arnilo/prism-provider-openai  # application profile
+npm install @arnilo/prism-all                               # every first-party package
+npm install @arnilo/prism-server @arnilo/prism-workflows    # optional Web API boundary
+npm install @arnilo/prism-supervisor                         # optional local delegation + A2A 1.0
 ```
 
 See [docs/release-and-install.md](docs/release-and-install.md) for install
@@ -56,6 +60,17 @@ specifiers, tarball contents, and the offline test budget.
 
 ## Quick start
 
+Scaffold a tiny project (offline mock test included):
+
+```bash
+npx --package @arnilo/prism prism init my-agent
+# or, with a real provider package selected:
+npx --package @arnilo/prism prism init my-agent --provider openai
+cd my-agent && npm install && npm test
+```
+
+Or embed Prism directly:
+
 ```ts
 import { createAgent, createAgentSession, createMockProvider } from "@arnilo/prism";
 
@@ -67,9 +82,18 @@ const agent = createAgent({
 
 const session = createAgentSession({ agent });
 
-// Consume the event stream concurrently with the run. `subscribe()` only
-// emits while a run is in progress, so the loop and `run()` must run together;
-// awaiting the loop before calling `run()` would deadlock.
+// Direct result: run/prompt return AgentRunResult (text, usage, status, ids).
+const result = await session.run("Hi");
+console.log(result.text, result.usage?.totalTokens);
+
+// Integrated streaming: subscribe-before-run for one owned run.
+for await (const event of session.stream("Hi again")) {
+  // AgentEvent: agent_started, message_delta, turn_finished, ...
+}
+
+// Long-lived subscribe() still works when you need a subscriber across runs.
+// `subscribe()` only emits while a run is in progress, so the loop and `run()`
+// must run together; awaiting the loop before calling `run()` would deadlock.
 (async () => {
   const consumer = (async () => {
     for await (const event of session.subscribe()) {
@@ -111,8 +135,8 @@ printf '{"id":"1","command":"prompt","params":{"input":"Hi"}}\n' \
 
 - [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).
+  offline demos covering providers, auth, tools, stores, compaction, structured
+  output, multimodality, workflows, CLI, and RPC.
 
 ## Packages
 
@@ -127,9 +151,22 @@ printf '{"id":"1","command":"prompt","params":{"input":"Hi"}}\n' \
 | `@arnilo/prism-provider-neuralwatt` | NeuralWatt provider with implicit vLLM prefix caching |
 | `@arnilo/prism-compaction-llm` | provider-backed compaction strategy |
 | `@arnilo/prism-compaction-observational-memory` | source-backed memory + recall tool |
-| `@arnilo/prism-providers` | umbrella: all 6 provider adapters |
-| `@arnilo/prism-compaction` | umbrella: both compaction strategies |
-| `@arnilo/prism-all` | umbrella: core + providers + compaction |
+| `@arnilo/prism-coding-agent` | bounded shell/read/write/edit tools |
+| `@arnilo/prism-coding-security` | coding approval, containment, and sandbox adapters |
+| `@arnilo/prism-tool-validator-json-schema` | bounded JSON Schema tool validation |
+| `@arnilo/prism-mcp` | MCP client/tool bridge |
+| `@arnilo/prism-workflows` | bounded DAG workflows, durable suspend/resume, schedules/background runs, composition/state/replay, and multi-process coordination |
+| `@arnilo/prism-supervisor` | bounded local child delegation and A2A 1.0 interoperability |
+| `@arnilo/prism-observability-opentelemetry` | optional OpenTelemetry adapter |
+| `@arnilo/prism-credentials-node` | encrypted-file and keychain credentials |
+| `@arnilo/prism-session-store-sqlite` | SQLite persistence/checkpoints/leases/owned run feedback |
+| `@arnilo/prism-session-store-postgres` | PostgreSQL persistence/checkpoints/leases/owned run feedback |
+| `@arnilo/prism-providers` | family: all 7 provider adapters, including AI SDK interoperability |
+| `@arnilo/prism-compaction` | family: both compaction strategies |
+| `@arnilo/prism-base` | profile: core + compaction + JSON Schema validation |
+| `@arnilo/prism-code` | profile: base + coding tools/security + MCP |
+| `@arnilo/prism-sdk` | profile: base + workflows + MCP + credentials + OpenTelemetry |
+| `@arnilo/prism-all` | every first-party package, including both persistence adapters |
 
 ## Scripts
 
@@ -142,8 +179,7 @@ printf '{"id":"1","command":"prompt","params":{"input":"Hi"}}\n' \
 
 ## 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.
+- Privileged tools, MCP servers, telemetry, credentials, or databases activated by install — hosts explicitly configure and register every capability.
+- Browser automation or interactive terminal UI — CLI/RPC and workflow control APIs only.
+- Provider, credential, extension, or package auto-discovery.
+- Core-owned database drivers, secret persistence, sandbox, or application policy — optional packages implement adapters over host-owned boundaries.

package/dist/agent-loops.d.ts

@@ -1,4 +1,4 @@
-import type { AgentLoopOptions, AgentLoopStrategy, ArtifactParser, ArtifactRepairer, ArtifactValidator } from "./contracts.js";
+import type { AgentLoopOptions, AgentLoopStrategy, ArtifactParser, ArtifactRepairer, ArtifactValidator, LoopContext, ToolCallContent } from "./contracts.js";
 export declare const singleShotLoop: AgentLoopStrategy;
 export declare function isAgentLoopOptions(value: AgentLoopStrategy | AgentLoopOptions | undefined): value is AgentLoopOptions;
 export declare function generateValidateReviseLoop(opts: {
@@ -7,6 +7,13 @@ export declare function generateValidateReviseLoop(opts: {
     readonly repairer?: ArtifactRepairer<unknown>;
     readonly maxRevisions?: number;
 }): AgentLoopStrategy;
+export declare function resolveToolConcurrency(options: {
+    loop?: AgentLoopStrategy | AgentLoopOptions;
+}, config: {
+    loop?: AgentLoopStrategy | AgentLoopOptions;
+}): number;
+/** Dispatch tool calls with bounded concurrency; append transcript rows in call order. */
+export declare function dispatchToolCallsInOrder(calls: readonly ToolCallContent[], ctx: LoopContext): Promise<void>;
 export declare function resolveLoop(options: {
     loop?: AgentLoopStrategy | AgentLoopOptions;
 }, config: {

package/dist/agent-loops.js

@@ -18,13 +18,12 @@ export const singleShotLoop = {
     name: "single-shot",
     async run(ctx) {
         let usage;
-        const toolResults = [];
         let toolRounds = 0;
         let nextInput = ctx.input;
         for (let turn = 1;; turn += 1) {
             throwIfAborted(ctx.signal);
             ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-            const request = await ctx.assemble(nextInput, toolResults, turn);
+            const request = await ctx.assemble(nextInput, undefined, turn);
             throwIfAborted(ctx.signal);
             const { content, calls, messageId, started, usage: turnUsage } = await ctx.generate(request);
             usage = turnUsage ?? usage;
@@ -40,12 +39,7 @@ export const singleShotLoop = {
             if (calls.length === 0 || toolRounds >= ctx.maxToolRounds)
                 break;
             toolRounds += 1;
-            for (const call of calls) {
-                const result = await ctx.dispatchToolCall(call);
-                toolResults.push(result);
-                await ctx.appendMessage(toolResultMessage(result));
-                throwIfAborted(ctx.signal);
-            }
+            await dispatchToolCallsInOrder(calls, ctx);
             nextInput = [];
         }
         return usage;
@@ -73,6 +67,7 @@ export function generateValidateReviseLoop(opts) {
         async run(ctx) {
             let usage;
             let nextInput = ctx.input;
+            let pendingHistory = [];
             for (let turn = 1; turn <= max + 1; turn += 1) {
                 throwIfAborted(ctx.signal);
                 ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
@@ -80,6 +75,10 @@ export function generateValidateReviseLoop(opts) {
                 throwIfAborted(ctx.signal);
                 const { content, messageId, started, usage: turnUsage } = await ctx.generate(request);
                 usage = turnUsage ?? usage;
+                if (pendingHistory.length > 0) {
+                    ctx.history.push(...pendingHistory);
+                    pendingHistory = [];
+                }
                 if (turn === 1)
                     ctx.history.push(...ctx.inputMessages);
                 if (started) {
@@ -121,10 +120,9 @@ export function generateValidateReviseLoop(opts) {
                 ctx.emit({ type: "artifact_revision_started", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, failure: result });
                 const repair = await repairer(parsed.value, result, artifactCtx);
                 const repairMessages = inputMessages(repair).map((m) => ({ ...m, id: randomId("msg") }));
-                for (const message of repairMessages) {
-                    ctx.history.push(message);
+                for (const message of repairMessages)
                     await ctx.appendMessage(message);
-                }
+                pendingHistory = repairMessages;
                 nextInput = repairMessages;
                 continue;
             }
@@ -135,6 +133,54 @@ export function generateValidateReviseLoop(opts) {
 // ponytail: resolveLoop returns the loop to run. RunOptions.loop wins over
 // AgentConfig.loop; default is singleShotLoop. generate-validate-revise maps
 // its options to the factory; unknown strategy throws.
+export function resolveToolConcurrency(options, config) {
+    const loop = options.loop ?? config.loop;
+    if (!loop || !isAgentLoopOptions(loop) || loop.strategy !== "single-shot")
+        return 1;
+    const value = loop.toolConcurrency;
+    if (value === undefined)
+        return 1;
+    if (!Number.isFinite(value) || value < 1)
+        return 1;
+    return Math.floor(value);
+}
+/** Dispatch tool calls with bounded concurrency; append transcript rows in call order. */
+export async function dispatchToolCallsInOrder(calls, ctx) {
+    if (calls.length === 0)
+        return;
+    const concurrency = calls.some((call) => ctx.isToolCallExclusive?.(call))
+        ? 1
+        : Math.max(1, Math.min(ctx.toolConcurrency, calls.length));
+    if (concurrency === 1) {
+        for (const call of calls) {
+            const result = await ctx.dispatchToolCall(call);
+            await appendToolResultMessage(result, ctx);
+        }
+        return;
+    }
+    const results = new Array(calls.length);
+    let nextIndex = 0;
+    const workers = Array.from({ length: concurrency }, async () => {
+        for (;;) {
+            throwIfAborted(ctx.signal);
+            const index = nextIndex;
+            nextIndex += 1;
+            if (index >= calls.length)
+                return;
+            results[index] = await ctx.dispatchToolCall(calls[index]);
+        }
+    });
+    await Promise.all(workers);
+    for (const result of results) {
+        throwIfAborted(ctx.signal);
+        await appendToolResultMessage(result, ctx);
+    }
+}
+async function appendToolResultMessage(result, ctx) {
+    const message = toolResultMessage(result);
+    ctx.history.push(message);
+    await ctx.appendMessage(message);
+}
 export function resolveLoop(options, config) {
     const loop = options.loop ?? config.loop;
     if (!loop)