@arnilo/prism 0.0.4 → 0.0.6

package/CHANGELOG.md

@@ -5,7 +5,52 @@ 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]
+## [0.0.6] - 2026-07-19
+
+### Added
+
+- Caller-gated model discovery: `listOpenAIModels`, `listKimiModels`, `listZaiModels`, `listOpenRouterModels`, and `listOpenCodeGoModels`. Provider setup remains network-free; hosts explicitly fetch and register current models.
+- Shared `ThinkingLevel` helpers and use-case model bindings. Background compaction and observational-memory jobs can use an explicit provider/model or a supplied session-model fallback.
+- Opt-in sequential artifact-loop tools: `loop: { strategy: "generate-validate-revise", toolCalls: "bounded" }`. Tool rounds use existing authorization/redaction/ledger paths, share `maxToolRounds` across candidates, and fail with `artifact_failed` metadata `{ reason: "tool_round_limit" }` after exhaustion.
+- Checksummed SQLite/PostgreSQL migration histories and catalog-shape verification, bounded JSON Schema compilation LRU, and public `assertFiniteVector` validation.
+
+### Changed
+
+- Provider packages now document and implement current cache, reasoning, streaming, and discovery behavior. OpenAI Responses replay/function-call/SSE argument handling is corrected; Kimi adds optional Moonshot support; Z.AI and OpenCode Go catalogs/routes were refreshed; OpenRouter discovery/reasoning and NeuralWatt thinking controls are hardened. AI SDK remains host-model-owned.
+- Workflow definitions now require a non-empty `revision`; cancellation requires exact ownership and the current workflow definition. All workflow limits have finite hard caps.
+- Coding tools now enforce bounded streamed reads, write/edit inputs, shell wall time, total output, and spill-file lifecycle. Custom coding operation interfaces now receive bounded read/stat/write/edit options and abort signals.
+- Encrypted credential helpers `encryptBytes`, `decryptBytes`, and envelope rotation are asynchronous. Existing credential files must meet restrictive Unix permission requirements. Linux Secret Service/GNOME Keyring byte-array reads are accepted by the keychain store.
+- MCP Streamable HTTP requires HTTPS and explicit `allowedOrigins`; loopback HTTP requires explicit opt-in. Discovery, schemas, results, and response bodies are bounded.
+- Compaction and observational-memory workers now have finite turn/call/transcript/error budgets. A2A streaming uses strict incremental UTF-8 and LF/CRLF SSE parsing.
+- Generated Prism, workflow, and evaluation IDs use cryptographic UUIDs; non-finite embedding vectors now fail before scoring or persistence.
+
+### Security
+
+- Fixed cross-owner workflow cancellation and duplicate active-run overwrite risks.
+- Added fail-closed limits and validation at file, process, credential, MCP, migration, schema, vector, provider-worker, and A2A trust boundaries.
+
+### Upgrade notes
+
+- Finish or deliberately migrate pre-0.0.6 workflow runs/checkpoints before upgrading: their definition hashes lack the required revision.
+- Update workflow definitions with `revision`, cancellation callers with `workflow` plus exact ownership, MCP HTTP configs with `allowedOrigins`, and custom coding/credential integrations for the changed interfaces above.
+
+## [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
 

package/README.md

@@ -26,13 +26,14 @@ packages. Prism defines contracts, not apps.
 - **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
 
@@ -50,6 +51,8 @@ npm install @arnilo/prism-base                              # core + compaction
 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
@@ -57,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";
 
@@ -68,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()) {
@@ -132,12 +155,13 @@ printf '{"id":"1","command":"prompt","params":{"input":"Hi"}}\n' \
 | `@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 and durable coordination |
+| `@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 |
-| `@arnilo/prism-session-store-postgres` | PostgreSQL persistence/checkpoints/leases |
-| `@arnilo/prism-providers` | family: all 6 provider adapters |
+| `@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 |

package/dist/agent-loops.d.ts

@@ -6,6 +6,7 @@ export declare function generateValidateReviseLoop(opts: {
     readonly parser?: ArtifactParser<unknown>;
     readonly repairer?: ArtifactRepairer<unknown>;
     readonly maxRevisions?: number;
+    readonly toolCalls?: "disabled" | "bounded";
 }): AgentLoopStrategy;
 export declare function resolveToolConcurrency(options: {
     loop?: AgentLoopStrategy | AgentLoopOptions;

package/dist/agent-loops.js

@@ -1,4 +1,5 @@
 import { inputMessages } from "./input.js";
+import { createId } from "./ids.js";
 function throwIfAborted(signal) {
     if (signal.aborted)
         throw signal.reason instanceof Error ? signal.reason : new Error("Agent run aborted");
@@ -55,10 +56,8 @@ function defaultRepairer() {
     });
 }
 // ponytail: GenerateValidateReviseLoop reuses LoopContext primitives only —
-// no provider/retry/store/event re-implementation. T is host-defined, Prism
-// never instantiates it. No tools in artifact revisions (roadmap scope is
-// generate→validate→revise; tool coupling deferred). Phase 28 fires
-// artifact_* events at the marked seams (noop here).
+// no provider/retry/store/event re-implementation. Bounded artifact tools use
+// same dispatcher at concurrency one; add parallelism only with ordering need.
 export function generateValidateReviseLoop(opts) {
     const max = opts.maxRevisions ?? 3;
     const repairer = opts.repairer ?? defaultRepairer();
@@ -68,12 +67,14 @@ export function generateValidateReviseLoop(opts) {
             let usage;
             let nextInput = ctx.input;
             let pendingHistory = [];
-            for (let turn = 1; turn <= max + 1; turn += 1) {
+            let toolRounds = 0;
+            let attempts = 0;
+            for (let turn = 1; attempts <= max; turn += 1) {
                 throwIfAborted(ctx.signal);
                 ctx.emit({ type: "turn_started", sessionId: ctx.sessionId, runId: ctx.runId, turn });
                 const request = await ctx.assemble(nextInput, undefined, turn);
                 throwIfAborted(ctx.signal);
-                const { content, messageId, started, usage: turnUsage } = await ctx.generate(request);
+                const { content, calls, messageId, started, usage: turnUsage } = await ctx.generate(request);
                 usage = turnUsage ?? usage;
                 if (pendingHistory.length > 0) {
                     ctx.history.push(...pendingHistory);
@@ -88,10 +89,17 @@ export function generateValidateReviseLoop(opts) {
                     ctx.emit({ type: "message_finished", sessionId: ctx.sessionId, runId: ctx.runId, message });
                 }
                 ctx.emit({ type: "turn_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn });
-                const text = content
-                    .filter((b) => b.type === "text")
-                    .map((b) => b.text)
-                    .join("");
+                if (opts.toolCalls === "bounded" && calls.length > 0) {
+                    if (toolRounds >= ctx.maxToolRounds) {
+                        const result = { ok: false, errors: [{ message: "maximum tool rounds exceeded" }], metadata: { reason: "tool_round_limit" } };
+                        ctx.emit({ type: "artifact_failed", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt: attempts + 1, result });
+                        return usage;
+                    }
+                    toolRounds += 1;
+                    await dispatchToolCallsInOrder(calls, { ...ctx, toolConcurrency: 1 });
+                    nextInput = [];
+                    continue;
+                }
                 const artifactCtx = {
                     sessionId: ctx.sessionId,
                     runId: ctx.runId,
@@ -99,13 +107,17 @@ export function generateValidateReviseLoop(opts) {
                     signal: ctx.signal,
                     metadata: ctx.metadata,
                 };
+                const text = content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("");
                 const parsed = opts.parser
                     ? await opts.parser(text, artifactCtx)
                     : { ok: true, value: text };
                 // Parse failure ends the loop silently (terminal parse errors stay on `error`).
                 if (!parsed.ok || parsed.value === undefined)
                     return usage;
-                const attempt = turn;
+                const attempt = ++attempts;
                 ctx.emit({ type: "artifact_validation_started", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt });
                 const result = await opts.validator(parsed.value, artifactCtx);
                 ctx.emit({ type: "artifact_validation_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, result });
@@ -113,7 +125,7 @@ export function generateValidateReviseLoop(opts) {
                     ctx.emit({ type: "artifact_finished", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, result });
                     return usage;
                 }
-                if (turn > max) {
+                if (attempt > max) {
                     ctx.emit({ type: "artifact_failed", sessionId: ctx.sessionId, runId: ctx.runId, turn, attempt, result });
                     return usage;
                 }
@@ -124,7 +136,6 @@ export function generateValidateReviseLoop(opts) {
                     await ctx.appendMessage(message);
                 pendingHistory = repairMessages;
                 nextInput = repairMessages;
-                continue;
             }
             return usage;
         },
@@ -195,13 +206,12 @@ export function resolveLoop(options, config) {
                 parser: loop.parser,
                 repairer: loop.repairer,
                 maxRevisions: loop.maxRevisions,
+                toolCalls: loop.toolCalls,
             });
         }
         throw new Error(`Unknown agent loop strategy: ${strategy}`);
     }
     return loop;
 }
-function randomId(prefix) {
-    return `${prefix}_${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
-}
+const randomId = createId;
 //# sourceMappingURL=agent-loops.js.map

package/dist/agents.js

@@ -1,4 +1,6 @@
+import { AgentRunError } from "./contracts.js";
 import { resolveLoop, resolveToolConcurrency } from "./agent-loops.js";
+import { createId } from "./ids.js";
 import { createProviderTurnMetadata, readProviderHttpStatus } from "./observability.js";
 import { createDefaultCompactionStrategy, isCompactionEntryData } from "./compaction.js";
 import { assembleProviderInput } from "./input.js";
@@ -71,6 +73,8 @@ class RuntimeAgentSession {
         const model = options.model ?? this.agent.config.model;
         const startedAt = new Date().toISOString();
         let runError;
+        const runUsage = createUsageAccumulator();
+        let usage;
         try {
             this.resolveRunProvider(options);
             throwIfAborted(controller.signal);
@@ -114,6 +118,23 @@ class RuntimeAgentSession {
             const loop = resolveLoop(options, this.agent.config);
             const toolConcurrency = resolveToolConcurrency(options, this.agent.config);
             this.activeLoopTurn = 1;
+            const recordProviderUsage = async (turnUsage, turn, attempt) => {
+                runUsage.add(turnUsage);
+                if (!this.activeLedger)
+                    return;
+                const usageRecord = {
+                    id: randomId("usage"),
+                    sessionId: this.id,
+                    runId,
+                    scope: "provider_turn",
+                    turn,
+                    attempt,
+                    usage: turnUsage,
+                    recordedAt: new Date().toISOString(),
+                    ...this.activeOwnership,
+                };
+                await this.activeLedger.appendUsage(redactRunLedgerRecord(usageRecord, this.activeRedactor));
+            };
             // ponytail: LoopContext binds existing private helpers; loop orchestrates only.
             const ctx = {
                 sessionId: this.id,
@@ -152,7 +173,7 @@ class RuntimeAgentSession {
                 generate: async (request) => {
                     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;
-                    return this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn);
+                    return this.generateWithRetry(this.redactProviderRequest(middlewareRequest), runId, options, controller.signal, policyResult.secrets, this.activeLoopTurn, recordProviderUsage);
                 },
                 isToolCallExclusive: (call) => registry.get(call.name)?.exclusive === true,
                 dispatchToolCall: (call) => dispatchToolCall({
@@ -175,12 +196,14 @@ class RuntimeAgentSession {
                     this.emit(event);
                 },
             };
-            const usage = await loop.run(ctx);
+            const loopUsage = await loop.run(ctx);
+            usage = runUsage.value() ?? loopUsage;
             if (usage && this.activeLedger) {
                 const usageRecord = {
                     id: randomId("usage"),
                     sessionId: this.id,
                     runId,
+                    scope: "run_total",
                     usage,
                     recordedAt: new Date().toISOString(),
                     ...this.activeOwnership,
@@ -189,11 +212,23 @@ class RuntimeAgentSession {
             }
             await this.drainLedger();
             this.emit({ type: "agent_finished", sessionId: this.id, runId, usage });
+            return this.buildRunResult({
+                runId,
+                status: "succeeded",
+                usage,
+            });
         }
         catch (error) {
             runError = errorToErrorInfo(error);
             this.emit({ type: "error", sessionId: this.id, runId, error: runError });
-            throw error;
+            const result = this.buildRunResult({
+                runId,
+                status: controller.signal.aborted ? "aborted" : "failed",
+                usage: runUsage.value() ?? usage,
+                error: runError,
+                abortReason: controller.signal.aborted ? String(controller.signal.reason) : undefined,
+            });
+            throw new AgentRunError(result, { cause: error });
         }
         finally {
             if (this.activeRun === controller)
@@ -233,6 +268,48 @@ class RuntimeAgentSession {
     prompt(input, options) {
         return this.run(input, options);
     }
+    async *stream(input, options = {}) {
+        const { maxQueuedEvents, overflow, ...runOptions } = options;
+        const subscription = this.subscribe({ maxQueuedEvents, overflow });
+        let runOwnedId;
+        let settled = false;
+        const runPromise = this.run(input, runOptions).finally(() => {
+            settled = true;
+        });
+        try {
+            for await (const event of subscription) {
+                if ("runId" in event && typeof event.runId === "string") {
+                    if (runOwnedId === undefined && event.type === "agent_started")
+                        runOwnedId = event.runId;
+                    if (runOwnedId !== undefined && event.runId !== runOwnedId)
+                        continue;
+                }
+                yield event;
+            }
+            await runPromise;
+        }
+        finally {
+            if (!settled) {
+                this.abort(new Error("stream consumer closed"));
+                await runPromise.catch(() => undefined);
+            }
+        }
+    }
+    buildRunResult(input) {
+        const final = finalAssistantMessage(this.history);
+        return {
+            sessionId: this.id,
+            runId: input.runId,
+            status: input.status,
+            leafId: this.currentLeafId,
+            text: final.text,
+            content: final.content,
+            message: final.message,
+            usage: input.usage,
+            error: input.error,
+            abortReason: input.abortReason,
+        };
+    }
     async compact(options = {}) {
         if (this.activeRun)
             throw new Error("Agent session already has an active run");
@@ -340,13 +417,13 @@ class RuntimeAgentSession {
         if (failure)
             throw failure;
     }
-    async generateWithRetry(request, runId, options, signal, requestSecrets = [], turn = 1) {
+    async generateWithRetry(request, runId, options, signal, requestSecrets = [], turn = 1, recordUsage) {
         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, turn, attempt);
+                return await this.generateProviderTurn(request, runId, signal, secrets, turn, attempt, recordUsage);
             }
             catch (error) {
                 const failure = error instanceof ProviderTurnFailure ? error : undefined;
@@ -365,7 +442,7 @@ class RuntimeAgentSession {
             }
         }
     }
-    async generateProviderTurn(request, runId, signal, secrets = [], turn = 1, attempt = 1) {
+    async generateProviderTurn(request, runId, signal, secrets = [], turn = 1, attempt = 1, recordUsage) {
         const startedAt = performance.now();
         const providerId = this.activeProvider?.id ?? request.model.provider;
         const buildMetadata = (extra = {}) => createProviderTurnMetadata(request, providerId, { attempt, ...extra });
@@ -382,25 +459,20 @@ class RuntimeAgentSession {
         let messageId;
         let started = false;
         let usage;
+        let usageRecorded = false;
+        const recordTurnUsage = async () => {
+            if (!usage || usageRecorded)
+                return;
+            usageRecorded = true;
+            await recordUsage?.(usage, turn, attempt);
+        };
         try {
             for await (const event of this.activeProvider.generate(request)) {
                 throwIfAborted(signal);
                 if (event.type === "error")
                     throw new ProviderTurnFailure(event.error, started);
-                if (event.type === "usage") {
+                if (event.type === "usage")
                     usage = event.usage;
-                    if (this.activeLedger) {
-                        const usageRecord = {
-                            id: randomId("usage"),
-                            sessionId: this.id,
-                            runId,
-                            usage: event.usage,
-                            recordedAt: new Date().toISOString(),
-                            ...this.activeOwnership,
-                        };
-                        await this.activeLedger.appendUsage(redactRunLedgerRecord(usageRecord, this.activeRedactor));
-                    }
-                }
                 if (event.type === "done") {
                     usage = event.usage ?? usage;
                     break;
@@ -433,6 +505,7 @@ class RuntimeAgentSession {
                 calls.push(call);
                 this.emit({ type: "message_delta", sessionId: this.id, runId, content: call });
             }
+            await recordTurnUsage();
             const latencyMs = Math.round(performance.now() - startedAt);
             this.emit({
                 type: "provider_turn_finished",
@@ -447,12 +520,14 @@ class RuntimeAgentSession {
         catch (error) {
             const latencyMs = Math.round(performance.now() - startedAt);
             const info = error instanceof ProviderTurnFailure ? redactSecrets(error.info, secrets) : errorToErrorInfo(error, secrets);
+            await recordTurnUsage();
             this.emit({
                 type: "provider_turn_finished",
                 sessionId: this.id,
                 runId,
                 turn,
                 metadata: buildMetadata({ latencyMs, httpStatus: readProviderHttpStatus(info) }),
+                usage,
                 error: info,
             });
             if (error instanceof ProviderTurnFailure)
@@ -608,6 +683,19 @@ function inputToMessages(input) {
         return [input];
     return [...input];
 }
+function finalAssistantMessage(history) {
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const message = history[index];
+        if (message.role !== "assistant")
+            continue;
+        const text = message.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        return { message, content: message.content, text };
+    }
+    return { content: [], text: "" };
+}
 function activeTools(tools) {
     if (!tools)
         return { registry: createToolRegistry(), tools: [] };
@@ -673,7 +761,45 @@ 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)}`;
+function createUsageAccumulator() {
+    const sums = new Map();
+    let costCurrency;
+    let costCompatible = true;
+    return {
+        add(usage) {
+            for (const key of ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"]) {
+                const value = usage[key];
+                if (value !== undefined)
+                    sums.set(key, (sums.get(key) ?? 0) + value);
+            }
+            const total = usage.totalTokens
+                ?? (usage.inputTokens !== undefined || usage.outputTokens !== undefined
+                    ? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0)
+                    : undefined);
+            if (total !== undefined)
+                sums.set("totalTokens", (sums.get("totalTokens") ?? 0) + total);
+            if (usage.cost !== undefined && costCompatible) {
+                if (!sums.has("cost"))
+                    costCurrency = usage.currency;
+                else if (usage.currency !== costCurrency)
+                    costCompatible = false;
+                if (costCompatible)
+                    sums.set("cost", (sums.get("cost") ?? 0) + usage.cost);
+            }
+        },
+        value() {
+            if (sums.size === 0)
+                return undefined;
+            const usage = {};
+            for (const [key, value] of sums) {
+                if (key !== "cost" || costCompatible)
+                    usage[key] = value;
+            }
+            if (costCompatible && sums.has("cost") && costCurrency !== undefined)
+                usage.currency = costCurrency;
+            return Object.keys(usage).length > 0 ? usage : undefined;
+        },
+    };
 }
+const randomId = createId;
 //# sourceMappingURL=agents.js.map

package/dist/cli-init.d.ts

@@ -0,0 +1,41 @@
+import type { Writable } from "node:stream";
+export declare class InitUsageError extends Error {
+}
+export type InitProvider = string;
+export interface InitOptions {
+    readonly directory: string;
+    readonly provider: InitProvider;
+    readonly withWorkflows: boolean;
+    readonly withEvals: boolean;
+    readonly force: boolean;
+    readonly help: boolean;
+}
+export interface InitRuntime {
+    readonly stdout: Writable;
+    readonly stderr: Writable;
+    /** Override template root (tests). Defaults to package `templates/init`. */
+    readonly templatesRoot?: string;
+    /** Override package version stamped into generated package.json. */
+    readonly packageVersion?: string;
+    /** Working directory used to resolve relative destinations. Defaults to process.cwd(). */
+    readonly cwd?: string;
+}
+export interface InitResult {
+    readonly targetDir: string;
+    readonly writtenFiles: readonly string[];
+    readonly provider: InitProvider;
+    readonly withWorkflows: boolean;
+    readonly withEvals: boolean;
+    readonly totalBytes: number;
+}
+/** Provider ids supported by `prism init --provider`. Loaded from templates data. */
+export declare function listInitProviders(templatesRoot?: string): readonly string[];
+/** @deprecated Prefer listInitProviders(); retained for tests that import the name. */
+export declare const INIT_PROVIDERS: readonly string[];
+export declare function getInitUsage(templatesRoot?: string): string;
+export declare const initUsage: string;
+export declare function parseInitArgs(argv: readonly string[], templatesRoot?: string): InitOptions;
+export declare function runInitCommand(argv: readonly string[], runtime: InitRuntime): Promise<number>;
+export declare function createInitProject(options: InitOptions, runtime?: InitRuntime): Promise<InitResult>;
+export declare function defaultTemplatesRoot(): string;
+export declare function isInitProvider(value: string, templatesRoot?: string): value is InitProvider;