booths 1.4.0 → 1.4.1

package/README.md

@@ -1,93 +1,72 @@
 # Booths
 
-Booths is a modular and extensible framework for building and managing conversational AI agents. It provides a structured way to define the capabilities, context, and tools for different AI-powered conversational flows.
+[![Check Build on Pull Request](https://github.com/phoneburner/booths/actions/workflows/build-check.yml/badge.svg)](https://github.com/phoneburner/booths/actions/workflows/build-check.yml)
+[![Format Check](https://github.com/phoneburner/booths/actions/workflows/format-check.yml/badge.svg)](https://github.com/phoneburner/booths/actions/workflows/format-check.yml)
+[![Publish to NPM on Release](https://github.com/phoneburner/booths/actions/workflows/release.yml/badge.svg)](https://github.com/phoneburner/booths/actions/workflows/release.yml)
+[![Test Suite](https://github.com/phoneburner/booths/actions/workflows/test.yml/badge.svg)](https://github.com/phoneburner/booths/actions/workflows/test.yml)
 
-The system is designed around a central `CoreBooth` class that orchestrates interactions between users and a Large Language Model (LLM), leveraging a system of registries and plugins to manage the conversational state and capabilities.
+*A modular, extensible framework for building and managing conversational AI agents in TypeScript.*
 
-## Architecture Overview
+> Booths provides a structured way to define agent capabilities, context, and tools, orchestrated by a `CoreBooth` that manages the interaction loop with your LLM and a rich plugin lifecycle.
 
-The Booths framework is built around a few key concepts that work together to create a powerful and flexible conversational AI system.
+---
 
-```mermaid
-graph TD
-    subgraph Application Layer
-        A[Your Application]
-    end
+## Table of Contents
 
-    subgraph Booth Service Layer
-        C(CoreBooth)
-    end
+* [Installation](#installation)
+* [Quick Start Guide](#quick-start-guide)
+* [Architecture Overview](#architecture-overview)
+* [API Reference](#api-reference)
 
-    subgraph Core Components
-        D[Interaction Processor]
-        E[LLM Adapter]
-        F[Registries]
-        G[Plugins]
-    end
+    * [createCoreBooth](#createcorebooth)
 
-    A -- "initializes and calls" --> C
-    C -- "delegates to" --> D
-    D -- "uses" --> E
-    D -- "uses" --> F
-    D -- "executes" --> G
-    E -- "communicates with" --> H((LLM))
-    F -- "manages" --> I{Booths}
-    F -- "manages" --> J{Tools}
-    F -- "manages" --> K{Plugins}
-    G -- "hook into" --> D
+        * [Options](#options)
+        * [Examples](#examples)
+    * [InteractionProcessor](#interactionprocessor)
 
-    style C fill:#f9f,stroke:#333,stroke-width:2px
-```
+        * [Flow](#flow)
+        * [Important Constraints](#important-constraints)
+    * [Registries](#registries)
 
-1.  **Application Layer**: Your application integrates the Booths framework to handle conversational AI interactions.
-2.  **`CoreBooth`**: The framework foundation that provides global functionality, instructions, and infrastructure that applies to all booths. It manages the overall system configuration and coordinates the interaction flow.
-3.  **`InteractionProcessor`**: The engine that drives the conversation. It takes user input, runs it through the plugin lifecycle, sends it to the LLM (via the adapter), and processes the response.
-4.  **`LLMAdapter`**: A component that handles communication with the specific LLM provider (e.g., OpenAI). It translates requests and responses between the Booths system and the LLM's API.
-5.  **Registries**: These are responsible for managing the different components of the system:
-    *   `BoothRegistry`: Manages `BoothConfig` objects that define the behavior of different AI agents.
-    *   `ToolRegistry`: Manages the tools (functions) that booths can use.
-    *   `BoothPluginRegistry`: Manages the plugins that hook into the conversational lifecycle.
-6.  **Plugins**: These are modules that add functionality to the system by hooking into the `InteractionProcessor`'s lifecycle (e.g., managing conversation history, providing context to the LLM, executing tools).
+        * [BoothRegistry](#boothregistry)
+        * [ToolRegistry](#toolregistry)
+        * [BoothPluginRegistry](#boothpluginregistry)
+    * [Plugins](#plugins)
 
-## Getting Started
+        * [Lifecycle Hooks](#lifecycle-hooks)
+* [Best Practices](#best-practices)
+* [Advanced Usage](#advanced-usage)
 
-The Booths framework is designed as a TypeScript library for building conversational AI systems. This repository contains the core framework implementation.
+    * [Customizing the end-of-turn marker](#customizing-the-end-of-turn-marker)
+    * [Per-tool interception & error recovery](#per-tool-interception--error-recovery)
+* [Types](#types)
+* [Session & State Management](#session--state-management)
+* [Error Handling](#error-handling)
+* [License](#license)
 
-### Installation
+---
+
+## Installation
 
 ```bash
 npm install booths
 ```
 
-### Prerequisites
-
--   Node.js and npm installed
--   An LLM provider API key (e.g., OpenAI)
+**Prerequisites**
 
-### Development
-
-To build the library:
-
-```bash
-npm run build
-```
+* Node.js and npm
+* An API key for your LLM provider (e.g., OpenAI)
 
-To check types:
-
-```bash
-npm run typecheck
-```
+---
 
 ## Quick Start Guide
 
-Here is a lightweight example of how to set up and use the Core Booth system manually.
-
-### 1. Define a Booth
+A minimal setup that defines a booth, a tool, an adapter, and starts a conversation.
 
-First, define a booth configuration. This object specifies the booth's identity, role, and the tools it can use.
+### 1) Define a Booth
 
-```typescript
-// in my-booths.ts
+```ts
+// my-booths.ts
 import type { BoothConfig } from 'booths';
 
 export const pirateBooth: BoothConfig = {
@@ -99,12 +78,10 @@ export const pirateBooth: BoothConfig = {
 };
 ```
 
-### 2. Define a Tool
+### 2) Define a Tool
 
-Next, create a tool that the booth can use. A tool is a function that the LLM can decide to call.
-
-```typescript
-// in my-tools.ts
+```ts
+// my-tools.ts
 import type { ToolModule } from 'booths';
 
 export const tellPirateJokeTool: ToolModule = {
@@ -113,122 +90,256 @@ export const tellPirateJokeTool: ToolModule = {
   description: 'Tells a classic pirate joke.',
   parameters: { type: 'object', properties: {} },
   execute: async () => {
-    return { joke: "Why are pirates called pirates? Because they arrrr!" };
+    return { joke: 'Why are pirates called pirates? Because they arrrr!' };
   },
 };
 ```
 
-### 3. Implement the LLM Adapter
-
-The `CoreBooth` requires an `LLMAdapter` to communicate with your chosen language model. Here is a minimal example for OpenAI.
+### 3) Implement a simple LLM Adapter
 
-```typescript
-// in OpenAIAdapter.ts
-import type { LLMAdapter, ResponseCreateParamsNonStreaming, Response } from 'booths';
+```ts
+// OpenAIAdapter.ts
+import type {
+  LLMAdapter,
+  ResponseCreateParamsNonStreaming,
+  Response,
+} from 'booths';
 import OpenAI from 'openai';
 
 export class OpenAIAdapter implements LLMAdapter<Response> {
   private openai: OpenAI;
-
   constructor(apiKey: string) {
     this.openai = new OpenAI({ apiKey });
   }
-
   async invoke(params: ResponseCreateParamsNonStreaming): Promise<Response> {
     return this.openai.responses.create({ ...params, model: 'gpt-4o' });
   }
-
   async interpret(response: Response): Promise<Response> {
     return response;
   }
 }
 ```
 
-### 4. Initialize the CoreBooth
-
-Finally, use the `createCoreBooth` factory to instantiate the system.
+### 4) Initialize and talk to the booth
 
-```typescript
-// in main.ts
+```ts
+// main.ts
 import { createCoreBooth } from 'booths';
 import { pirateBooth } from './my-booths';
 import { tellPirateJokeTool } from './my-tools';
-import { OpenAIAdapter } from './openAIAdapter';
-
-// 1. Create the LLM adapter
-const llmAdapter = new OpenAIAdapter('your-openai-api-key');
-
-// 2. Create the CoreBooth instance
-const coreBooth = createCoreBooth(llmAdapter, pirateBooth);
+import { OpenAIAdapter } from './OpenAIAdapter';
 
-// Optional: Customize the end interaction loop marker
-// const coreBooth = createCoreBooth(llmAdapter, pirateBooth, {
-//   endInteractionLoopMarker: '__custom_marker__'
-// });
+const llmAdapter = new OpenAIAdapter(process.env.OPENAI_API_KEY!);
+const coreBooth = createCoreBooth(llmAdapter, pirateBooth /*, { endInteractionLoopMarker: '__custom_marker__' }*/);
 
-// 3. Register the tool (this step will be improved in future versions)
+// Register tools (available to the current booth)
 coreBooth.toolRegistry.registerTools([tellPirateJokeTool]);
 
-// 4. Send a message and get a response
-async function haveConversation() {
-  const userInput = 'Tell me a pirate joke.';
-  const response = await coreBooth.callProcessor.send(userInput);
-
+// Send a message and read the result
+async function run() {
+  const response = await coreBooth.callProcessor.send('Tell me a pirate joke.');
   console.log(response.output_text);
-  // Expected output: "Why are pirates called pirates? Because they arrrr!"
 }
+run();
+```
+
+---
+
+## Architecture Overview
+
+```mermaid
+graph TD
+    subgraph Application Layer
+        A[Your Application]
+    end
+
+    subgraph Booth Service Layer
+        C(CoreBooth)
+    end
+
+    subgraph Core Components
+        D[Interaction Processor]
+        E[LLM Adapter]
+        F[Registries]
+        G[Plugins]
+    end
+
+    A -- "initializes and calls" --> C
+    C -- "delegates to" --> D
+    D -- "uses" --> E
+    D -- "uses" --> F
+    D -- "executes" --> G
+    E -- "communicates with" --> H((LLM))
+    F -- "manages" --> I{Booths}
+    F -- "manages" --> J{Tools}
+    F -- "manages" --> K{Plugins}
+    G -- "hook into" --> D
+```
+
+---
 
-haveConversation();
+## API Reference
+
+### createCoreBooth
+
+Factory that wires an `LLMAdapter`, a `BoothConfig`, and internal registries/plugins into a working `CoreBooth` instance.
+
+```ts
+function createCoreBooth(
+  adapter: LLMAdapter<any>,
+  booth: BoothConfig,
+  options?: { endInteractionLoopMarker?: string }
+): CoreBooth
+```
+
+#### Options
+
+| Name                       | Type     |                        Default | Description                                           |
+| -------------------------- | -------- | -----------------------------: | ----------------------------------------------------- |
+| `endInteractionLoopMarker` | `string` | `"__awaiting_user_response__"` | Marker used by plugins to determine when a turn ends. |
+
+#### Examples
+
+**Basic**
+
+```ts
+const coreBooth = createCoreBooth(adapter, pirateBooth);
+```
+
+**Custom end-of-turn marker**
+
+```ts
+const coreBooth = createCoreBooth(adapter, pirateBooth, {
+  endInteractionLoopMarker: '__custom_marker__',
+});
 ```
-## How It Works
 
-The Core Booth system is comprised of several key components that work together to process user input and generate contextual responses.
+---
+
+### InteractionProcessor
+
+Engine that manages the interaction loop with the LLM and the plugin lifecycle.
+
+#### Flow
+
+1. Take user input
+2. Run `onBefore...` plugin hooks
+3. Send payload via `LLMAdapter`
+4. Receive response
+5. Run `onResponseReceived` hooks (e.g., execute tools)
+6. Repeat until `shouldEndInteractionLoop` returns `true`
+7. Run `onAfter...` hooks for cleanup
+
+#### Important Constraints
+
+* **Ordering matters**: tool execution and hook order follow the loop above.
+* **End-of-turn detection** relies on the configured `endInteractionLoopMarker`.
+
+---
+
+### Registries
+
+Booths uses three registries to manage the system’s moving parts.
+
+#### BoothRegistry
+
+* Manages `BoothConfig` objects (each is a specialized agent: role, description, tools, examples).
+* Tracks the current context booth.
+
+#### ToolRegistry
+
+* Stores tools available to the LLM (as `ToolModule`).
+* Provides registration helpers like `registerTools([...])`.
+
+#### BoothPluginRegistry
+
+* Manages plugins that hook into the interaction lifecycle.
+* Enables modular capabilities like conversation history, context provisioning, tool provisioning/execution, and turn-finalization.
+
+---
+
+### Plugins
+
+Plugins implement `BoothPlugin` and can influence request/response flow and tool execution.
+
+#### Lifecycle Hooks
+
+* `onBeforeInteractionLoopStart`
+* `onBeforeMessageSend`
+* `onResponseReceived`
+* `onBeforeToolCall`
+* `onAfterToolCall`
+* `onToolCallError`
+* `shouldEndInteractionLoop`
+* `onAfterInteractionLoopEnd`
+
+**Built-in plugin capabilities (typical set)**
+
+* `ConversationHistoryPlugin` – maintains conversation history
+* `ContextProviderPlugin` – supplies booth context to the LLM
+* `ToolProviderPlugin` – exposes available tools
+* `ToolExecutorPlugin` – executes tool calls with per-call hooks
+* `FinishTurnPlugin` – decides when a turn is complete
+
+---
+
+## Best Practices
+
+* Keep tools **pure** and **idempotent** when possible; return structured results.
+* Favor **small, composable plugins**; use `onBeforeToolCall`/`onAfterToolCall`/`onToolCallError` to isolate auth, caching, and audit.
+* Clearly separate **global tools** vs **booth-specific tools** and document access rules.
+* Centralize **end-of-turn logic** to avoid inconsistent session behavior.
+
+---
+
+## Advanced Usage
+
+### Customizing the end-of-turn marker
+
+```ts
+createCoreBooth(adapter, booth, { endInteractionLoopMarker: '__custom__' });
+```
+
+Use this to coordinate UI or multi-agent systems that rely on explicit “awaiting user” signals.
+
+### Per-tool interception & error recovery
+
+```ts
+class AuditPlugin implements BoothPlugin {
+  async onBeforeToolCall(ctx) { /* validate or redact */ }
+  async onAfterToolCall(ctx) { /* persist results */ }
+  async onToolCallError(ctx, err) { /* fallback or retry */ }
+}
+```
 
-### 1. Registries
+These hooks enable authentication, caching, and graceful degradation at the **individual tool** level.
 
-- **`BoothRegistry`**: Manages the collection of `BoothConfig` objects. Each booth represents a specialized agent with a specific role, description, and set of tools. It also keeps track of the "current context booth" to ensure the conversation stays on topic.
-- **`ToolRegistry`**: Manages the tools that can be made available to the LLM. Tools are functions that the AI can decide to call to perform actions or retrieve information.
-- **`BoothPluginRegistry`**: Manages plugins that hook into the interaction lifecycle. This allows for modular and reusable functionality to be added to the system.
+---
 
-### 2. Plugins
+## Types
 
-Plugins are classes that implement the `BoothPlugin` interface. They can execute logic at different stages of the conversation:
+Core concepts you’ll interact with most:
 
-- `onBeforeInteractionLoopStart`: Before the main loop begins.
-- `onBeforeMessageSend`: Before a message is sent to the LLM.
-- `onResponseReceived`: After a response is received from the LLM.
-- `onBeforeToolCall`: Before each individual tool call is executed _(allows modification of tool parameters, validation, and logging)_.
-- `onAfterToolCall`: After each individual tool call is successfully executed _(allows result processing, caching, and transformation)_.
-- `onToolCallError`: When a tool call encounters an error _(allows custom error handling and recovery)_.
-- `shouldEndInteractionLoop`: To determine if the conversation turn is over.
-- `onAfterInteractionLoopEnd`: After the main loop has finished.
+* `BoothConfig`: identity, role, description, `tools: string[]`, sample `examples`
+* `ToolModule`: `{ type: 'function' | ..., name, description, parameters, execute }`
+* `LLMAdapter<TResponse>`: `{ invoke(params): Promise<TResponse>; interpret(response): Promise<TResponse> }`
 
-The system includes several core plugins by default:
+---
 
-- `ConversationHistoryPlugin`: Maintains the history of the conversation.
-- `ContextProviderPlugin`: Provides the LLM with the context of the current booth.
-- `ToolProviderPlugin`: Provides the LLM with the available tools for the current booth.
-- `ToolExecutorPlugin`: Executes tool calls requested by the LLM with granular hook support for individual tool call interception.
-- `FinishTurnPlugin`: Determines when the LLM's turn is finished and it's waiting for user input. The marker used to detect conversation end can be customized via the `endInteractionLoopMarker` option (defaults to `__awaiting_user_response__`).
+## Session & State Management
 
-#### Enhanced Tool Call Management
+* Conversation continuity (history, context booth) is typically maintained by plugins.
+* Tool calls may emit intermediate results/messages; design UI to handle “in-progress” states.
 
-The plugin system now provides granular control over individual tool executions through three new hooks:
+---
 
-- **`onBeforeToolCall`**: Intercept and modify tool calls before execution (parameter validation, authorization, logging)
-- **`onAfterToolCall`**: Process and transform tool results after successful execution (caching, metadata addition, data transformation)
-- **`onToolCallError`**: Handle tool execution errors with custom recovery logic (fallback responses, error logging, graceful degradation)
+## Error Handling
 
-This enables sophisticated tool management patterns like authentication, caching, audit logging, and error recovery at the individual tool level.
+* Surface adapter/transport errors from `invoke`.
+* Prefer plugin-level `onToolCallError` for tool failures; use retries or fallback responses.
 
-### 3. Interaction Processor
+---
 
-The `InteractionProcessor` is the engine of the system. It manages the interaction loop with the LLM:
+## License
 
-1. It takes user input.
-2. Runs the `onBefore...` plugin hooks.
-3. Sends the payload to the LLM.
-4. Receives the response.
-5. Runs the `onResponseReceived` plugin hooks to process the response (e.g., execute tools).
-6. Repeats this loop until a plugin's `shouldEndInteractionLoop` returns `true`.
-7. Runs the `onAfter...` plugin hooks for cleanup.
+Distributed under the project’s LICENSE file.

package/dist/index.d.ts

@@ -408,6 +408,13 @@ export declare class BoothRegistry {
      * @returns Record of all booth configurations indexed by their IDs
      */
     getAllBooths(): Record<string, BoothConfig>;
+    /**
+     * Returns only booths that should be available for routing (excludes core and orchestrator booths).
+     * This prevents double context issues by ensuring system booths are not selectable.
+     *
+     * @returns Record of selectable booth configurations indexed by their IDs
+     */
+    getSelectableBooths(): Record<string, BoothConfig>;
     toArray(): BoothConfig[];
     /**
      * Enables multi-booth mode by registering the orchestrator and setting it as current context.
@@ -899,6 +906,12 @@ export declare class ToolExecutorPlugin implements BoothPlugin {
      * @private
      */
     private executeToolCall;
+    /**
+     * Extracts function call objects from an array of response output items.
+     *
+     * @param {ResponseOutputItem[]} output - The array of response output items to filter.
+     * @return {ResponseFunctionToolCall[]} An array containing only the function call objects from the input.
+     */
     static extractFunctionCalls(output: ResponseOutputItem[]): ResponseFunctionToolCall[];
     /**
      * After a response is received from the LLM, this hook checks for tool calls. If any are found,

package/dist/index.js

@@ -202,7 +202,7 @@ class y {
     return s;
   }
 }
-const h = {
+const u = {
   id: "orchestrator",
   role: `
     This booth serves as the orchestration layer that analyzes user intent and routes
@@ -315,7 +315,7 @@ class T {
     if (this.booths[t.id])
       return;
     this.booths[t.id] = t, Object.keys(this.booths).filter(
-      (e) => e !== h.id
+      (e) => e !== u.id
     ).length > 1 && !this.hasOrchestrator && this.enableMultiBoothMode();
   }
   /**
@@ -384,6 +384,18 @@ class T {
   getAllBooths() {
     return this.booths;
   }
+  /**
+   * Returns only booths that should be available for routing (excludes core and orchestrator booths).
+   * This prevents double context issues by ensuring system booths are not selectable.
+   *
+   * @returns Record of selectable booth configurations indexed by their IDs
+   */
+  getSelectableBooths() {
+    const t = {};
+    for (const [o, e] of Object.entries(this.booths))
+      o !== this.baseBooth.id && o !== u.id && (t[o] = e);
+    return t;
+  }
   toArray() {
     return Object.values(this.booths);
   }
@@ -392,14 +404,14 @@ class T {
    * @private
    */
   enableMultiBoothMode() {
-    this.hasOrchestrator || (this.booths[h.id] = h, this.hasOrchestrator = !0, this.currentContextId = h.id, this.onMultiBoothModeEnabled?.());
+    this.hasOrchestrator || (this.booths[u.id] = u, this.hasOrchestrator = !0, this.currentContextId = u.id, this.onMultiBoothModeEnabled?.());
   }
   /**
    * Disables multi-booth mode by unregistering the orchestrator and resetting context to base booth.
    * @private
    */
   disableMultiBoothMode() {
-    this.hasOrchestrator && (delete this.booths[h.id], this.hasOrchestrator = !1, this.currentContextId = this.baseBooth.id, this.onMultiBoothModeDisabled?.());
+    this.hasOrchestrator && (delete this.booths[u.id], this.hasOrchestrator = !1, this.currentContextId = this.baseBooth.id, this.onMultiBoothModeDisabled?.());
   }
   /**
    * Sets callback functions for when multi-booth mode is enabled/disabled.
@@ -413,7 +425,7 @@ class T {
   }
   get isMultiBoothMode() {
     return Object.keys(this.booths).filter(
-      (o) => o !== h.id
+      (o) => o !== u.id
     ).length > 1;
   }
   /**
@@ -425,12 +437,12 @@ class T {
   unregisterBooth(t) {
     if (!this.booths[t])
       throw new Error(`Booth with ID ${t} does not exist.`);
-    if (t === h.id)
+    if (t === u.id)
       throw new Error(
         "Cannot unregister orchestrator booth directly. It will be automatically managed based on booth count."
       );
     delete this.booths[t], Object.keys(this.booths).filter(
-      (e) => e !== h.id
+      (e) => e !== u.id
     ).length <= 1 && this.hasOrchestrator && this.disableMultiBoothMode();
   }
 }
@@ -607,7 +619,7 @@ const v = {
   description: "A specialized booth for summarizing conversation histories."
 }, m = "route_to_booth";
 function b(n) {
-  const t = n.getAllBooths(), o = Object.values(t).map(
+  const t = n.getSelectableBooths(), o = Object.values(t).map(
     (r) => `- ${r.id}: ${r.role}
   Examples:
 ${(r.examples || []).map((s) => `    - "${s}"`).join(`
@@ -989,12 +1001,12 @@ class A {
    * @returns The updated response parameters with the aggregated list of tools.
    */
   async onBeforeMessageSend(t, o) {
-    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, l = [...e.tools || [], ...r?.tools || []].filter((u, c, g) => g.indexOf(u) === c).map(
-      (u) => t.toolRegistry.getTool(u)
+    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, l = [...e.tools || [], ...r?.tools || []].filter((h, c, g) => g.indexOf(h) === c).map(
+      (h) => t.toolRegistry.getTool(h)
     );
     if (e.mcp && l.push(...e.mcp), r?.mcp && l.push(...r.mcp), t.boothRegistry.isMultiBoothMode) {
-      const u = b(t.boothRegistry);
-      l.push(u);
+      const h = b(t.boothRegistry);
+      l.push(h);
     }
     l.push(...t.toolRegistry.getGlobalTools());
     const d = M(l);
@@ -1071,6 +1083,12 @@ class w {
       };
     }
   }
+  /**
+   * Extracts function call objects from an array of response output items.
+   *
+   * @param {ResponseOutputItem[]} output - The array of response output items to filter.
+   * @return {ResponseFunctionToolCall[]} An array containing only the function call objects from the input.
+   */
   static extractFunctionCalls(t) {
     return t.filter(
       (o) => o.type === "function_call"
@@ -1094,12 +1112,12 @@ class w {
       const d = s[l];
       if (t.toolRegistry.isLocalTool(d.name))
         continue;
-      const u = {
+      const h = {
         responseParams: o,
         response: e,
         toolCallIndex: l,
         totalToolCalls: s.length
-      }, c = await this.executeToolCall(t, d, u);
+      }, c = await this.executeToolCall(t, d, h);
       i.push(c);
     }
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "booths",
   "private": false,
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",