booths 1.4.0 → 1.5.0

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,259 @@ 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,
+  ResponseInput,
+} 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
+> **Note**: All necessary types including `ResponseInput` and `ResponseInputItem` can be imported directly from `booths`, eliminating the need to import from the OpenAI library.
 
-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');
+import { OpenAIAdapter } from './OpenAIAdapter';
 
-// 2. Create the CoreBooth instance
-const coreBooth = createCoreBooth(llmAdapter, pirateBooth);
+const llmAdapter = new OpenAIAdapter(process.env.OPENAI_API_KEY!);
+const coreBooth = createCoreBooth(llmAdapter, pirateBooth /*, { endInteractionLoopMarker: '__custom_marker__' }*/);
 
-// Optional: Customize the end interaction loop marker
-// 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
 
-haveConversation();
+```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
+```
+
+---
+
+## 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__',
+});
+```
+
+---
+
+### 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__' });
 ```
-## How It Works
 
-The Core Booth system is comprised of several key components that work together to process user input and generate contextual responses.
+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.cjs

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class f{plugins=[];registerPlugin(t){if(this.plugins.some(o=>o.id===t.id))throw new Error(`Plugin with ID ${t.id} is already registered.`);this.plugins.push(t)}getPlugins(){return this.plugins}registerPlugins(t){for(const o of t)this.registerPlugin(o)}getPluginById(t){return this.plugins.find(o=>o.id===t)}getPluginsByIds(t){const o=[];for(const e of t){const r=this.getPluginById(e);if(!r)throw new Error(`Plugin with ID ${e} is not registered.`);o.push(r)}return o}unregisterPlugin(t){const o=this.plugins.findIndex(e=>e.id===t);if(o===-1)throw new Error(`Plugin with ID ${t} does not exist.`);this.plugins.splice(o,1)}async runBeforeInteractionLoopStart(t,o,e){let r=o;for(const s of this.plugins)s.onBeforeInteractionLoopStart&&(r=await s.onBeforeInteractionLoopStart(t,r,e));return r}async runBeforeMessageSend(t,o){let e=o;for(const r of this.plugins)r.onBeforeMessageSend&&(e=await r.onBeforeMessageSend(t,e));return e}async runResponseReceived(t,o,e){let r=o;for(const s of this.plugins)s.onResponseReceived&&(r=await s.onResponseReceived(t,r,e));return r}async runShouldEndInteractionLoop(t,o,e){for(const r of this.plugins)if(await r.shouldEndInteractionLoop(t,o,e))return console.log(`BoothPluginRegistry: Plugin ${r.id} indicated loop should end.`),!0;return!1}async runAfterInteractionLoopEnd(t,o){let e=o;for(const r of this.plugins)r.onAfterInteractionLoopEnd&&(e=await r.onAfterInteractionLoopEnd(t,o));return e}async runBeforeToolCall(t,o,e){let r=o;for(const s of this.plugins)s.onBeforeToolCall&&(r=await s.onBeforeToolCall(t,r,e));return r}async runAfterToolCall(t,o,e,r){let s=e;for(const i of this.plugins)i.onAfterToolCall&&(s=await i.onAfterToolCall(t,o,s,r));return s}async runToolCallError(t,o,e,r){let s=`Error: ${e.message}`;for(const i of this.plugins)i.onToolCallError&&(s=await i.onToolCallError(t,o,e,r));return s}}const u={id:"orchestrator",role:`
+    This booth serves as the orchestration layer that analyzes user intent and routes
+    conversations to the most appropriate specialized booth configuration.
+  `,description:`
+    You are the orchestration layer responsible for determining which booth configuration
+    should be active based on user needs. Focus exclusively on routing - do not answer
+    questions or provide information directly to users.
+
+    [ROUTING STRATEGY]
+    - Analyze user request and route to the most appropriate specialized booth immediately
+    - This booth is only active for initial routing or when explicitly routed back to
+    - Once routed, the target booth handles the conversation until completion or re-routing
+
+    [ROUTING TARGETS]
+    - Ambiguous requests → Ask for clarification, then route appropriately
+
+    [CORE PRINCIPLES]
+    - Maintain illusion of single, continuous assistant
+    - Never reference booths, tools, or system mechanics to users
+    - Silent routing is preferred when intent is clear
+    - Only speak to users when clarification is absolutely necessary
+
+    [ROUTING BEHAVIOR]
+    - Clear intent: Route silently using route_to_booth() - do NOT respond to user
+    - Ambiguous intent: Ask user for clarification, then route once clarified
+    - Never respond to user AND route - it's either respond OR route, not both
+
+    [BEHAVIOR EXAMPLES]
+    - User: "How do I test my number?" → route_to_booth({ targetBooth: 'page-router-booth' })
+    - User: "I need help" → "What specifically would you like help with?" → then route based on response
+  `};class _{constructor(t,o){this.baseBooth=t,this.registerBooth(t),this.currentContextId=o||t.id}booths={};currentContextId;hasOrchestrator=!1;onMultiBoothModeEnabled;onMultiBoothModeDisabled;getCurrentContextId(){return this.currentContextId}setCurrentContextId(t){if(!this.booths[t])throw new Error(`Booth with ID ${t} is not registered.`);this.currentContextId=t}get currentContextBoothConfig(){const t=this.getBoothById(this.currentContextId);if(!t)throw new Error(`Booth with ID ${this.currentContextId} is not registered.`);return t}registerBooth(t){if(this.booths[t.id])return;this.booths[t.id]=t,Object.keys(this.booths).filter(e=>e!==u.id).length>1&&!this.hasOrchestrator&&this.enableMultiBoothMode()}get baseBoothConfig(){return this.baseBooth}get orchestratorBoothConfig(){const t=this.getBoothById("orchestrator");if(!t)throw new Error("Base booth does not have an orchestrator configuration.");return t}registerBooths(t){for(const o of t)this.registerBooth(o)}getBoothById(t){return this.booths[t]}getBoothsByIds(t){const o=[];for(const e of t){const r=this.getBoothById(e);if(!r)throw new Error(`Booth with ID ${e} is not registered.`);o.push(r)}return o}getAllBooths(){return this.booths}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)}enableMultiBoothMode(){this.hasOrchestrator||(this.booths[u.id]=u,this.hasOrchestrator=!0,this.currentContextId=u.id,this.onMultiBoothModeEnabled?.())}disableMultiBoothMode(){this.hasOrchestrator&&(delete this.booths[u.id],this.hasOrchestrator=!1,this.currentContextId=this.baseBooth.id,this.onMultiBoothModeDisabled?.())}setMultiBoothModeCallbacks(t,o){this.onMultiBoothModeEnabled=t,this.onMultiBoothModeDisabled=o}get isMultiBoothMode(){return Object.keys(this.booths).filter(o=>o!==u.id).length>1}unregisterBooth(t){if(!this.booths[t])throw new Error(`Booth with ID ${t} does not exist.`);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!==u.id).length<=1&&this.hasOrchestrator&&this.disableMultiBoothMode()}}class v{constructor(t,o,e,r){this.boothRegistry=t,this.boothPlugins=o,this.toolRegistry=e,this.llmAdapter=r}loopLimit=10;createErrorResponse(t,o){const e=t instanceof Error?t.message:"Unknown error occurred while calling LLM",r=t instanceof Error&&"code"in t&&typeof t.code=="string"?t.code:"server_error",s={code:"server_error",message:e};if(r&&(s.code=r),o.model===void 0)throw new Error("Model must be specified in response parameters for error handling.");return{id:`error_${Date.now()}_${Math.random().toString(36).substr(2,9)}`,created_at:Math.floor(Date.now()/1e3),output_text:"An error occurred while communicating with the language model.",error:s,incomplete_details:null,instructions:null,metadata:null,model:o.model,object:"response",output:[{id:`msg_${Date.now()}_${Math.random().toString(36).substr(2,9)}`,content:[{type:"output_text",text:`Error: ${e}. Please try again or contact support if the issue persists.`,annotations:[]}],role:"assistant",status:"completed",type:"message"}],parallel_tool_calls:o.parallel_tool_calls||!1,temperature:o.temperature||null,tool_choice:o.tool_choice||"auto",tools:o.tools||[],top_p:o.top_p||null,status:"failed"}}async callLLM(t,o){try{const e=await this.llmAdapter.invoke(t,o);return await this.llmAdapter.interpret(e)}catch(e){return console.log("Error calling LLM:",e),this.createErrorResponse(e,t)}}async runInteractionLoop(t){let o=0,e=t,r,s=!0;for(;s&&o<this.loopLimit;){o++;const i={toolRegistry:this.toolRegistry,boothRegistry:this.boothRegistry,pluginRegistry:this.boothPlugins,llmAdapter:this.llmAdapter};e=await this.boothPlugins.runBeforeMessageSend(i,e),r=await this.callLLM(e,i),e=await this.boothPlugins.runResponseReceived(i,e,r),await this.boothPlugins.runShouldEndInteractionLoop(i,e,r)&&(console.log("Ending interaction loop because 'shouldEndInteractionLoop' returned true."),s=!1)}if(!r)throw new Error("No response received from LLM");return r}async send(t){let o;typeof t=="string"?o=[{role:"user",content:t}]:o=t;let e={input:o,tools:[]};const r=this.boothPlugins;e=await this.boothPlugins.runBeforeInteractionLoopStart({toolRegistry:this.toolRegistry,boothRegistry:this.boothRegistry,pluginRegistry:r,llmAdapter:this.llmAdapter},e,t);let s=await this.runInteractionLoop(e);return s=await this.boothPlugins.runAfterInteractionLoopEnd({toolRegistry:this.toolRegistry,boothRegistry:this.boothRegistry,pluginRegistry:r,llmAdapter:this.llmAdapter},s),s}}const L={id:"summarizer",role:'You are a highly skilled summarization AI. Your task is to read a conversation history and provide a concise, neutral, and objective summary. The summary should capture the key points, decisions made, and any unresolved questions. It must be written from a third-person perspective and should be clear enough for another AI assistant to understand the full context and continue the conversation seamlessly without needing the original transcript. Do not add any conversational fluff or introductory phrases like "Here is the summary:".',description:"A specialized booth for summarizing conversation histories."},w="route_to_booth";function y(n){const t=n.getSelectableBooths(),o=Object.values(t).map(r=>`- ${r.id}: ${r.role}
+  Examples:
+${(r.examples||[]).map(s=>`    - "${s}"`).join(`
+`)}`).join(`
+`),e=Object.keys(t);return{type:"function",name:w,description:`
+    Routes the conversation to a specialized booth based on the user's needs. Each booth has a 
+    specific role and set of capabilities.
+    `,parameters:{type:"object",properties:{targetBooth:{type:"string",description:`
+          The ID of the booth to route the conversation to. Must be one of the following available 
+          booths:
+${o}
+          `,enum:e}},required:["targetBooth"],additionalProperties:!1},strict:!0,execute:async function({targetBooth:r}){try{return n.setCurrentContextId(r),{content:`Routed to booth ${r}`}}catch(s){return console.log("[routeToBoothTool] Error routing to booth:",s),{content:`Error: Unable to route to booth ${r}.`}}}}}class E{sessionHistory=[];plugin_id="conversation-history";plugin_name="Conversation History Plugin";plugin_description="A plugin to manage conversation history in booths.";responseContainsBoothChange(t){return t.output?t.output.some(o=>o.type==="function_call"?o.name===w:o.type==="message"&&"tool_calls"in o&&Array.isArray(o.tool_calls)?o.tool_calls.some(e=>e.type==="function"&&e.function.name===w):!1):!1}constructor(t=[]){this.sessionHistory=t}get history(){return this.sessionHistory}get id(){return this.plugin_id}get name(){return this.plugin_name}get description(){return this.plugin_description}async onBeforeInteractionLoopStart(t,o){const{input:e}=o,r=typeof e=="string"?[{role:"user",content:e}]:e||[];return this.sessionHistory.push(...r),{...o,input:this.sessionHistory}}async onResponseReceived(t,o,e){let s=[...o.input,...e?.output??[]];if(this.responseContainsBoothChange(e)){const l=`Please compact the following LLM conversation history. Take key points and make it useful for 
+an LLM that may need to look back for references. Conclude the summary with any next steps or
+actions needed to complete the conversation.
+
+The conversation History:
+${JSON.stringify(this.sessionHistory)}`.trim(),c=(await P(t.llmAdapter,L).callProcessor.send(l)).output,g=s.filter(a=>"role"in a&&a.role==="user").pop();console.log("LastUserMessage: ",g),console.log("Summary: ",c),console.log("Summary: ",c.join(""));let b="";const p=c.find(a=>a.type==="message");console.log("summaryMessages",p),p&&"type"in p&&p.type=="message"&&p.content.forEach(a=>{a.type==="output_text"&&(b+=a.text)}),console.log("summaryText",b);const R={role:"developer",content:`A conversation summary up to this point: ${b}`},T=s.filter(a=>!("role"in a&&a.role==="user"||"type"in a&&a.type==="message"));this.sessionHistory=g?[...T,R,g]:[...T,R],s=this.sessionHistory}else this.sessionHistory=s;return{...o,input:s}}async shouldEndInteractionLoop(){return!1}}class I{plugin_id="context-provider";plugin_name="Context Provider Plugin";plugin_description="A plugin to provide context to booths.";get id(){return this.plugin_id}get name(){return this.plugin_name}get description(){return this.plugin_description}async onBeforeMessageSend(t,o){const e=t.boothRegistry;let s=e.baseBoothConfig.description;if(e.isMultiBoothMode){const i=e.orchestratorBoothConfig,l=e.currentContextBoothConfig;s+=`
+
+ ${i.description}`,l.id!==i.id&&(s+=`
+
+ ${l.description}`)}return{...o,instructions:s}}async shouldEndInteractionLoop(){return!1}}class B{tools;constructor(){this.tools=new Map}registerTools(t){t.forEach(o=>this.registerTool(o))}registerTool(t){if(this.tools.has(t.name)){console.warn(`Tool with ID '${t.name}' is already registered. Duplicate registration ignored.`);return}this.tools.set(t.name,t)}getTool(t){const o=this.tools.get(t);if(!o)throw new Error(`Tool with name ${t} is not registered.`);return o}getToolsByNames(t){const o=[];for(const e of t){const r=this.getTool(e);o.push(r)}return o}getGlobalTools(){return Array.from(this.tools.values()).filter(t=>t.global)}getServerTools(){return Array.from(this.tools.values()).filter(t=>t.execute!==void 0)}getLocalTools(){return Array.from(this.tools.values()).filter(t=>t.execute===void 0)}isLocalTool(t){const o=this.tools.get(t);return o?o.execute===void 0:!1}unregisterTool(t){if(!this.tools.has(t))throw new Error(`Tool with ID ${t} is not registered.`);this.tools.delete(t)}}function $(n){switch(n.type){case"function":return`function:${n.name}`;case"mcp":return`mcp:${n.server_label}`;case"file_search":return`file_search:${n.vector_store_ids.join(",")}`;case"web_search_preview":case"web_search_preview_2025_03_11":return`web_search:${n.type}`;case"computer_use_preview":return`computer:${n.environment}:${n.display_width}x${n.display_height}`;case"code_interpreter":return`code_interpreter:${typeof n.container=="string"?n.container:"auto"}`;case"image_generation":return`image_generation:${n.model||"gpt-image-1"}`;case"local_shell":return"local_shell";default:return`${n.type}:${JSON.stringify(n)}`}}function A(n){const t=new Set,o=[];for(const e of n){const r=$(e);t.has(r)||(t.add(r),o.push(e))}return o}class C{description="A plugin to aggregate and provide tools from base and context booths.";id="tool-provider";name="Tool Provider Plugin";async onBeforeMessageSend(t,o){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 h=y(t.boothRegistry);l.push(h)}l.push(...t.toolRegistry.getGlobalTools());const d=A(l);return{...o,tools:d}}async shouldEndInteractionLoop(){return!1}}class m{id="tool-executor";name="Tool Executor";description="Checks for tool calls in the response, executes them, and adds the results to the message history.";async executeToolCall(t,o,e){try{const r=await t.pluginRegistry.runBeforeToolCall(t,o,e),s=t.toolRegistry.getTool(r.name);if(!s)return{type:"function_call_output",call_id:r.call_id,output:`Error: Tool '${r.name}' not found.`};if(!s.execute)return{type:"function_call_output",call_id:r.call_id,output:`Error: Tool '${r.name}' does not have an 'execute' method.`};const i=await s.execute(JSON.parse(r.arguments)),l=await t.pluginRegistry.runAfterToolCall(t,r,i,e);return l||console.log(`Booths.ToolExecutorPlugin: Tool execution returned an empty results for ${s.name}. This may result in 400 responses from the LLM.`),{type:"function_call_output",call_id:r.call_id,output:JSON.stringify(l)}}catch(r){console.log(`Error executing tool ${o.name}:`,r);const s=await t.pluginRegistry.runToolCallError(t,o,r,e);return{type:"function_call_output",call_id:o.call_id,output:typeof s=="string"?s:JSON.stringify(s)}}}static extractFunctionCalls(t){return t.filter(o=>o.type==="function_call")}async onResponseReceived(t,o,e){const r=e?.output??[],s=m.extractFunctionCalls(r);if(!s.length)return o;const i=[];for(let l=0;l<s.length;l++){const d=s[l];if(t.toolRegistry.isLocalTool(d.name))continue;const h={responseParams:o,response:e,toolCallIndex:l,totalToolCalls:s.length},c=await this.executeToolCall(t,d,h);i.push(c)}return{...o,input:[...o.input,...i]}}async shouldEndInteractionLoop(){return!1}}class M{constructor(t="__awaiting_user_response__"){this.marker=t}description="A plugin to ensure the interaction loop can be finished.";id="finish-turn-plugin";name="Finish Turn Plugin";async onBeforeMessageSend(t,o){let e=o.instructions||"";return e=`
+    
+
+ 
+    [MUST]
+    - Always add the marker "${this.marker}" at the end of your output when you have finished your part
+    - This marker indicates that the interaction loop should end.
+    
+    ${e}
+    `,{...o,instructions:e}}async shouldEndInteractionLoop(t,o,e){const s=JSON.stringify(e.output).includes(this.marker),i=e.status==="failed"||e.error!==null;return s||i}async onAfterInteractionLoopEnd(t,o){const e=JSON.stringify(o);if(e.includes(this.marker)){const r=e.replace(new RegExp(this.marker,"g"),"");return JSON.parse(r)}return o}}function P(n,t){const o=new _(t),e=new B,r=new f;return new x({llmAdapter:n,booths:o,tools:e,boothPlugins:r})}class x{boothPluginRegistry;boothRegistry;callProcessor;systemPluginsRegistry;toolRegistry;constructor(t){if(this.boothPluginRegistry=t?.boothPlugins??new f,this.boothRegistry=t.booths,this.toolRegistry=t?.tools??new B,this.boothRegistry.setMultiBoothModeCallbacks(()=>{const o=y(this.boothRegistry);this.toolRegistry.registerTools([o])},()=>{}),this.boothRegistry.isMultiBoothMode){const o=y(this.boothRegistry);this.toolRegistry.registerTools([o])}this.systemPluginsRegistry=new f,this.systemPluginsRegistry.registerPlugins([new E(t.sessionHistory),new I,new C,new m,new M(t.endInteractionLoopMarker)]),this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()),this.callProcessor=new v(this.boothRegistry,this.systemPluginsRegistry,this.toolRegistry,t.llmAdapter)}}exports.BoothPluginRegistry=f;exports.BoothRegistry=_;exports.ContextProviderPlugin=I;exports.ConversationHistoryPlugin=E;exports.CoreBooth=x;exports.FinishTurnPlugin=M;exports.InteractionProcessor=v;exports.ToolExecutorPlugin=m;exports.ToolProviderPlugin=C;exports.ToolRegistry=B;exports.createCoreBooth=P;exports.createRouteToBoothTool=y;

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.
@@ -848,6 +855,10 @@ export declare type RepositoryUtilities = {
 
 export { ResponseCreateParamsNonStreaming }
 
+export { ResponseInput }
+
+export { ResponseInputItem }
+
 /**
  * Represents the result of processing a single tool call.
  */
@@ -899,6 +910,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();
   }
 }
@@ -522,36 +534,18 @@ class E {
     let o = 0, e = t, r, s = !0;
     for (; s && o < this.loopLimit; ) {
       o++;
-      const i = this.boothPlugins;
-      e = await this.boothPlugins.runBeforeMessageSend(
-        {
-          toolRegistry: this.toolRegistry,
-          boothRegistry: this.boothRegistry,
-          pluginRegistry: i,
-          llmAdapter: this.llmAdapter
-        },
-        e
-      ), r = await this.callLLM(e, {
+      const i = {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
-        pluginRegistry: i,
+        pluginRegistry: this.boothPlugins,
         llmAdapter: this.llmAdapter
-      }), e = await this.boothPlugins.runResponseReceived(
-        {
-          toolRegistry: this.toolRegistry,
-          boothRegistry: this.boothRegistry,
-          pluginRegistry: i,
-          llmAdapter: this.llmAdapter
-        },
+      };
+      e = await this.boothPlugins.runBeforeMessageSend(i, e), r = await this.callLLM(e, i), e = await this.boothPlugins.runResponseReceived(
+        i,
         e,
         r
       ), await this.boothPlugins.runShouldEndInteractionLoop(
-        {
-          toolRegistry: this.toolRegistry,
-          boothRegistry: this.boothRegistry,
-          pluginRegistry: i,
-          llmAdapter: this.llmAdapter
-        },
+        i,
         e,
         r
       ) && (console.log("Ending interaction loop because 'shouldEndInteractionLoop' returned true."), s = !1);
@@ -607,7 +601,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(`
@@ -753,20 +747,23 @@ class I {
   async onResponseReceived(t, o, e) {
     let s = [...o.input, ...e?.output ?? []];
     if (this.responseContainsBoothChange(e)) {
-      const l = `Please summarize the following conversation history:
+      const l = `Please compact the following LLM conversation history. Take key points and make it useful for 
+an LLM that may need to look back for references. Conclude the summary with any next steps or
+actions needed to complete the conversation.
 
-${JSON.stringify(this.sessionHistory)}`, c = (await $(t.llmAdapter, v).callProcessor.send(l)).output, g = s.filter((a) => "role" in a && a.role === "user").pop();
+The conversation History:
+${JSON.stringify(this.sessionHistory)}`.trim(), c = (await $(t.llmAdapter, v).callProcessor.send(l)).output, g = s.filter((a) => "role" in a && a.role === "user").pop();
       console.log("LastUserMessage: ", g), console.log("Summary: ", c), console.log("Summary: ", c.join(""));
       let f = "";
       const p = c.find((a) => a.type === "message");
       console.log("summaryMessages", p), p && "type" in p && p.type == "message" && p.content.forEach((a) => {
         a.type === "output_text" && (f += a.text);
       }), console.log("summaryText", f);
-      const R = {
+      const B = {
         role: "developer",
         content: `A conversation summary up to this point: ${f}`
-      }, B = s.filter((a) => !("role" in a && a.role === "user" || "type" in a && a.type === "message"));
-      this.sessionHistory = g ? [...B, R, g] : [...B, R], s = this.sessionHistory;
+      }, R = s.filter((a) => !("role" in a && a.role === "user" || "type" in a && a.type === "message"));
+      this.sessionHistory = g ? [...R, B, g] : [...R, B], s = this.sessionHistory;
     } else
       this.sessionHistory = s;
     return {
@@ -945,7 +942,7 @@ class _ {
     this.tools.delete(t);
   }
 }
-function x(n) {
+function M(n) {
   switch (n.type) {
     case "function":
       return `function:${n.name}`;
@@ -968,15 +965,15 @@ function x(n) {
       return `${n.type}:${JSON.stringify(n)}`;
   }
 }
-function M(n) {
+function x(n) {
   const t = /* @__PURE__ */ new Set(), o = [];
   for (const e of n) {
-    const r = x(e);
+    const r = M(e);
     t.has(r) || (t.add(r), o.push(e));
   }
   return o;
 }
-class A {
+class P {
   description = "A plugin to aggregate and provide tools from base and context booths.";
   id = "tool-provider";
   name = "Tool Provider Plugin";
@@ -989,15 +986,15 @@ 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);
+    const d = x(l);
     return {
       ...o,
       tools: d
@@ -1071,6 +1068,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 +1097,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 {
@@ -1116,7 +1119,7 @@ class w {
     return !1;
   }
 }
-class P {
+class L {
   constructor(t = "__awaiting_user_response__") {
     this.marker = t;
   }
@@ -1176,14 +1179,14 @@ class P {
 }
 function $(n, t) {
   const o = new T(t), e = new _(), r = new y();
-  return new L({
+  return new A({
     llmAdapter: n,
     booths: o,
     tools: e,
     boothPlugins: r
   });
 }
-class L {
+class A {
   /**
    * Represents a registry that maintains a collection of plugins for a booth system.
    * The boothPluginRegistry is used to manage and access plugins that enhance
@@ -1252,9 +1255,9 @@ class L {
     this.systemPluginsRegistry = new y(), this.systemPluginsRegistry.registerPlugins([
       new I(t.sessionHistory),
       new C(),
-      new A(),
+      new P(),
       new w(),
-      new P(t.endInteractionLoopMarker)
+      new L(t.endInteractionLoopMarker)
     ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new E(
       this.boothRegistry,
       this.systemPluginsRegistry,
@@ -1268,11 +1271,11 @@ export {
   T as BoothRegistry,
   C as ContextProviderPlugin,
   I as ConversationHistoryPlugin,
-  L as CoreBooth,
-  P as FinishTurnPlugin,
+  A as CoreBooth,
+  L as FinishTurnPlugin,
   E as InteractionProcessor,
   w as ToolExecutorPlugin,
-  A as ToolProviderPlugin,
+  P as ToolProviderPlugin,
   _ as ToolRegistry,
   $ as createCoreBooth,
   b as createRouteToBoothTool

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "booths",
   "private": false,
-  "version": "1.4.0",
+  "version": "1.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -12,7 +12,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "scripts": {