@consensus-tools/universal 0.9.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 consensus-tools contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,451 @@
+# @consensus-tools/universal
+
+**Single-model AI pipelines are a reliability failure.** One model, one prompt, one answer — no accountability. When an autonomous agent decides to send an email, merge code, or escalate permissions, nothing checks whether that's a good idea.
+
+`@consensus-tools/universal` adds a governance layer in one line. Three rule-based reviewers (security, compliance, user-impact) screen every tool call using pattern matching — no LLM calls, no network requests, sub-millisecond overhead. Block, allow, or escalate based on a configurable policy. Adapters for LangChain, Vercel AI SDK, and MCP are loaded on demand.
+
+## Install
+
+```bash
+pnpm add @consensus-tools/universal
+```
+
+Optional peer dependencies (install only what you need):
+
+```bash
+pnpm add @consensus-tools/langchain   # LangChain adapter
+pnpm add @consensus-tools/ai-sdk      # Vercel AI SDK adapter
+pnpm add @consensus-tools/mcp         # MCP adapter
+```
+
+---
+
+## Quick Start
+
+### wrap — any tool executor
+
+```typescript
+import { consensus } from "@consensus-tools/universal";
+
+// Your existing tool executor
+async function myExecutor(toolName: string, args: Record<string, unknown>) {
+  // call the actual tool
+}
+
+// Wrap it — all calls now go through deliberation
+const safe = consensus.wrap(myExecutor);
+
+const result = await safe("send_email", {
+  to: "user@example.com",
+  body: "Your invoice is attached.",
+});
+```
+
+Objects with `.execute`, `.invoke`, or `.call` methods are also accepted:
+
+```typescript
+const safe = consensus.wrap(myToolRunner);         // ToolExecutor function
+const safe = consensus.wrap({ execute: fn });      // .execute method
+const safe = consensus.wrap({ invoke: fn });       // .invoke method
+const safe = consensus.wrap({ call: fn });         // .call method
+```
+
+---
+
+### langchain — LangChain chain adapter
+
+```typescript
+import { consensus } from "@consensus-tools/universal";
+import { ChatOpenAI } from "@langchain/openai";
+import { createOpenAIFunctionsAgent } from "langchain/agents";
+
+const model = new ChatOpenAI({ model: "gpt-4o" });
+const chain = createOpenAIFunctionsAgent({ llm: model, tools, prompt });
+
+// Wrap the chain — consensus reviews every tool call before execution
+const safeChain = await consensus.langchain(chain, {
+  policy: "supermajority",
+  failPolicy: "closed",
+});
+```
+
+Requires `@consensus-tools/langchain` as a peer dependency.
+
+---
+
+### aiSdk — Vercel AI SDK adapter
+
+```typescript
+import { consensus } from "@consensus-tools/universal";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+async function generate(prompt: string) {
+  return generateText({ model: openai("gpt-4o"), prompt });
+}
+
+// Wrap the generate function
+const safeGenerate = await consensus.aiSdk(generate, {
+  policy: "majority",
+  guards: ["agent_action", "publish"],
+});
+
+const result = await safeGenerate("Summarize last quarter's results.");
+```
+
+Requires `@consensus-tools/ai-sdk` as a peer dependency.
+
+---
+
+### mcp — MCP server adapter
+
+```typescript
+import { consensus } from "@consensus-tools/universal";
+
+// Returns a guarded MCP server instance
+const server = await consensus.mcp({
+  policy: "unanimous",
+  failPolicy: "closed",
+  logger: (event) => console.log("[mcp]", event),
+});
+```
+
+Requires `@consensus-tools/mcp` as a peer dependency.
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                      @consensus-tools/universal                      │
+│                                                                      │
+│   consensus.wrap()   consensus.langchain()  consensus.aiSdk()        │
+│   consensus.mcp()                                                    │
+└───────────────────────────┬──────────────────────────────────────────┘
+                            │ resolves Wrappable → ToolExecutor
+                            ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│                      @consensus-tools/wrapper                        │
+│   consensus<T>({ fn, reviewers, strategy, hooks })                   │
+│   aggregateScores() → DecisionResult<T>                              │
+│   action: "allow" | "block" | "retry" | "escalate"                  │
+└──────────────────┬──────────────────────────────────────────────────┘
+                   │ reviewer functions
+        ┌──────────┼───────────────┐
+        ▼          ▼               ▼
+  [security]  [compliance]  [user-impact]
+  GuardTemplate  GuardTemplate  GuardTemplate
+        │
+        └── built via @consensus-tools/guards
+            createGuardTemplate() → .asReviewer()
+
+┌─────────────────────────────────────────────────────────────────────┐
+│                   Configurable Guard Domains                         │
+│   send_email  code_merge  publish  support_reply                     │
+│   agent_action  deployment  permission_escalation                    │
+│                   @consensus-tools/guards (Tier 1)                   │
+└─────────────────────────────────────────────────────────────────────┘
+
+Tier layout (consensus-tools layered architecture):
+  Tier 0  schemas, secrets
+  Tier 1  guards, telemetry, evals, integrations, notifications
+  Tier 2  core (job engine, ledger), policies (9 algorithms)
+  Tier 3  workflows, wrapper
+  Tier 4  universal (this package), sdk-node, mcp, openclaw, cli
+```
+
+---
+
+## API Reference
+
+### `consensus.wrap(wrappable, config?)`
+
+Synchronously wraps a tool executor with consensus governance. Returns a `ToolExecutor`.
+
+```typescript
+function wrap(wrappable: Wrappable, config?: Partial<UniversalConfig>): ToolExecutor
+```
+
+| Parameter | Type | Description |
+|---|---|---|
+| `wrappable` | `Wrappable` | Function, or object with `.execute` / `.invoke` / `.call` |
+| `config` | `Partial<UniversalConfig>` | Optional configuration (see Config Reference below) |
+
+**Returns:** `ToolExecutor` — `(toolName: string, args: Record<string, unknown>) => Promise<unknown>`
+
+---
+
+### `consensus.langchain(chain, config?)`
+
+Async adapter for LangChain chains. Dynamically imports `@consensus-tools/langchain`.
+
+```typescript
+async function langchain(chain: unknown, config?: Partial<UniversalConfig>): Promise<unknown>
+```
+
+Throws `MissingDependencyError` if `@consensus-tools/langchain` is not installed.
+
+---
+
+### `consensus.aiSdk(fn, config?)`
+
+Async adapter for Vercel AI SDK generate functions. Dynamically imports `@consensus-tools/ai-sdk`.
+
+```typescript
+async function aiSdk(fn: unknown, config?: Partial<UniversalConfig>): Promise<unknown>
+```
+
+Throws `MissingDependencyError` if `@consensus-tools/ai-sdk` is not installed.
+
+---
+
+### `consensus.mcp(config?)`
+
+Async adapter that creates a guarded MCP server. Dynamically imports `@consensus-tools/mcp`.
+
+```typescript
+async function mcp(config?: Partial<UniversalConfig>): Promise<unknown>
+```
+
+Throws `MissingDependencyError` if `@consensus-tools/mcp` is not installed.
+
+---
+
+## Configuration Reference
+
+All options are optional. Defaults are shown.
+
+```typescript
+interface UniversalConfig {
+  policy?:     string;                              // "majority"
+  guards?:     string[];                            // ["agent_action"]
+  failPolicy?: "closed" | "open";                  // "closed"
+  storage?:    "memory" | IStorage;                // "memory"
+  logger?:     boolean | ((event: LogEvent) => void); // true
+  onDecision?: (decision: DecisionResult<unknown>) => void;
+  onError?:    (err: Error, action: unknown) => void;
+}
+```
+
+### `policy`
+
+Maps to an aggregation strategy for the three built-in reviewers.
+
+| Value | Strategy |
+|---|---|
+| `"majority"` (default) | More than half of reviewers approve |
+| `"supermajority"` | Weighted average score >= 0.67 |
+| `"unanimous"` | Every reviewer must approve |
+| `"threshold:X"` | Weighted average score >= X (0–1) |
+
+### `guards`
+
+Guard domain names to use as reviewers. Defaults to `["agent_action"]`. The seven built-in domains are documented in the Guard Domains section below.
+
+### `failPolicy`
+
+| Value | Behavior on deliberation error or block |
+|---|---|
+| `"closed"` (default) | Throw `ConsensusBlockedError` — the tool call does not execute |
+| `"open"` | Allow the tool call to proceed despite the deliberation result |
+
+**`failPolicy: "open"` effectively disables governance.** It exists for development and testing only. In production, use `"closed"` (the default) and handle `ConsensusBlockedError` in your error path.
+
+If you want to observe governance decisions without blocking in production, use `onDecision` instead:
+
+```typescript
+consensus.wrap(executor, {
+  failPolicy: "closed",
+  onDecision: (result) => {
+    // Shadow mode: log every decision, including blocks, for analysis
+    metrics.track("consensus.decision", { action: result.action, score: result.aggregateScore });
+  },
+});
+```
+
+**Production warning:** `failPolicy: "open"` and `storage: "memory"` both emit `console.warn` when `NODE_ENV=production`.
+
+### `storage`
+
+| Value | Description |
+|---|---|
+| `"memory"` (default) | In-process storage — decisions are not persisted across restarts |
+| `IStorage` | Any storage backend implementing the `IStorage` interface (e.g., `@consensus-tools/storage`) |
+
+### `logger`
+
+| Value | Description |
+|---|---|
+| `true` (default) | Emit structured log events via `console.debug` |
+| `false` | Disable all logging |
+| `(event: LogEvent) => void` | Custom log handler |
+
+```typescript
+// Custom logger example
+consensus.wrap(executor, {
+  logger: (event) => myObservability.track(event.event, event.data),
+});
+```
+
+### `onDecision`
+
+Called after every consensus deliberation, including allowed actions.
+
+```typescript
+consensus.wrap(executor, {
+  onDecision: (result) => {
+    auditLog.write({
+      action: result.action,
+      score: result.aggregateScore,
+      rationale: result.scores.map((s) => s.rationale),
+    });
+  },
+});
+```
+
+### `onError`
+
+Called when an unexpected error occurs during deliberation (not a block — a runtime failure).
+
+```typescript
+consensus.wrap(executor, {
+  onError: (err, context) => {
+    Sentry.captureException(err, { extra: context });
+  },
+});
+```
+
+---
+
+## Guard Domains
+
+The seven built-in guard domains correspond to the guard packages in this monorepo.
+
+| Domain | Description |
+|---|---|
+| `agent_action` | Pre-execution governance for autonomous agent actions (default) |
+| `send_email` | Email automation governance — flags mass sends, PII in bodies |
+| `code_merge` | PR / branch merge governance — flags sensitive file changes |
+| `publish` | Content publishing governance — flags unreviewed or regulated content |
+| `support_reply` | Customer support reply governance — flags tone, policy, escalation |
+| `deployment` | Release deployment governance — flags prod, rollback risk |
+| `permission_escalation` | IAM / privilege escalation governance — flags scope creep |
+
+---
+
+## Error Reference
+
+| Error class | When thrown |
+|---|---|
+| `ConsensusBlockedError` | Deliberation blocked the action and `failPolicy` is `"closed"` |
+| `MissingDependencyError` | Optional peer dependency not installed (langchain / ai-sdk / mcp) |
+| `ConfigError` | Invalid `policy` string passed to `policyToStrategy` |
+
+```typescript
+import { ConsensusBlockedError, MissingDependencyError } from "@consensus-tools/universal";
+
+try {
+  const result = await safe("permission_escalation", { scope: "admin" });
+} catch (err) {
+  if (err instanceof ConsensusBlockedError) {
+    // Deliberation blocked this call — log and surface to operator
+    console.error("Blocked:", err.message);
+  }
+}
+```
+
+---
+
+## OWASP Agentic Top 10 Mapping
+
+The table below maps each guard domain to the OWASP Agentic AI Security Initiative Top 10 categories it addresses.
+
+| # | OWASP Category | Addressed by guard domain(s) |
+|---|---|---|
+| 1 | **Excessive Agency** | `agent_action`, `permission_escalation` |
+| 2 | **Tool Misuse** | `agent_action`, `code_merge`, `deployment` |
+| 3 | **Prompt Injection** | `agent_action`, `support_reply` |
+| 4 | **Insecure Outputs** | `publish`, `support_reply`, `send_email` |
+| 5 | **Unauthorized Actions** | `permission_escalation`, `agent_action`, `deployment` |
+| 6 | **Data Leakage** | `send_email`, `publish`, `support_reply` |
+| 7 | **Supply Chain Attacks** | `code_merge`, `deployment` |
+| 8 | **Denial of Wallet** | `send_email`, `agent_action` |
+| 9 | **Unintended Autonomy** | `agent_action`, `permission_escalation` |
+| 10 | **Trust Boundary Violations** | `permission_escalation`, `code_merge`, `deployment` |
+
+### What happens at runtime
+
+When you call a wrapped tool executor, here's the exact sequence:
+
+```
+safe("send_email", { to: "user@example.com", body: "Your invoice" })
+  │
+  ├─ 1. Serialize args to text
+  │
+  ├─ 2. Run 3 reviewers IN PARALLEL (rule-based, no LLM calls):
+  │     ├─ security:    regex scan for destructive ops, secrets, injection
+  │     ├─ compliance:  regex scan for SSN patterns, PII, email addresses
+  │     └─ user-impact: regex scan for mass ops, irreversible actions
+  │
+  ├─ 3. Each reviewer returns: { vote: YES|NO|REWRITE, risk: 0-1, reason }
+  │
+  ├─ 4. Aggregate scores via policy (majority/supermajority/unanimous/threshold)
+  │     └─ Any reviewer can hard-block regardless of policy
+  │
+  ├─ 5. Decision: allow | block | retry | escalate
+  │
+  ├─ 6. Write audit artifact (to memory or configured storage)
+  │
+  └─ 7. Return result or throw ConsensusBlockedError
+```
+
+**Latency:** Sub-millisecond. Reviewers are synchronous regex evaluators, not LLM calls. The only async operation is the audit artifact write. Target: <10ms total overhead for the default 3-reviewer configuration.
+
+**DecisionResult object:**
+
+```typescript
+{
+  action: "allow",           // "allow" | "block" | "retry" | "escalate"
+  output: { ... },           // return value from the tool executor
+  scores: [
+    { score: 0.9, rationale: "No security concerns", block: false },
+    { score: 0.5, rationale: "Email PII detected", block: false },
+    { score: 0.9, rationale: "Low user impact", block: false },
+  ],
+  aggregateScore: 0.77,      // weighted average across reviewers
+  attempt: 1,                // retry count
+}
+```
+
+**Cost:** Zero. No API calls, no tokens consumed. The governance layer is pure computation.
+
+---
+
+## Exports
+
+| Export | Kind | Description |
+|---|---|---|
+| `consensus` | Object | Main facade with `.wrap()`, `.langchain()`, `.aiSdk()`, `.mcp()` |
+| `resolveWrappable` | Function | Resolves a `Wrappable` to a plain `ToolExecutor` |
+| `policyToStrategy` | Function | Maps a policy name string to a `StrategyConfig` |
+| `createLogger` | Function | Creates structured lifecycle log hooks |
+| `DEFAULTS` | Const | Default config values |
+| `DEFAULT_GUARD` | Const | `"agent_action"` |
+| `DEFAULT_POLICY` | Const | `"majority"` |
+| `DEFAULT_PERSONA_TRIO` | Const | `["security", "compliance", "user-impact"]` |
+| `DEFAULT_PERSONA_COUNT` | Const | `3` |
+| `ConsensusBlockedError` | Class | Thrown when deliberation blocks and `failPolicy` is `"closed"` |
+| `MissingDependencyError` | Class | Thrown when an optional peer dep is not installed |
+| `ConfigError` | Class | Thrown for invalid configuration (e.g., unknown policy name) |
+| `Wrappable` | Type | `ToolExecutor \| { execute } \| { invoke } \| { call }` |
+| `ToolExecutor` | Type | `(toolName: string, args: Record<string, unknown>) => Promise<unknown>` |
+| `UniversalConfig` | Type | Full configuration interface |
+| `FailPolicy` | Type | `"closed" \| "open"` |
+| `LogEvent` | Type | `{ event: string; data: Record<string, unknown>; timestamp: number }` |
+
+---
+
+## Links
+
+[consensus-tools on GitHub](https://github.com/consensus-tools/consensus-tools)

package/dist/__tests__/defaults.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=defaults.test.d.ts.map

package/dist/__tests__/defaults.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/defaults.test.ts"],"names":[],"mappings":""}