booths 0.0.6 → 0.1.0

package/README.md

@@ -1,146 +1,192 @@
-# Core Booth System
+# 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.
+
+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.
+
+## Architecture Overview
+
+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 User Interface
+        A[Vue.js Component]
+    end
+
+    subgraph Booth Service Layer
+        B(useLLMService)
+        C(CoreBooth)
+    end
+
+    subgraph Core Components
+        D[Interaction Processor]
+        E[LLM Adapter]
+        F[Registries]
+        G[Plugins]
+    end
+
+    A -- "sends user input" --> B
+    B -- "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
+
+    style B fill:#f9f,stroke:#333,stroke-width:2px
+    style C fill:#f9f,stroke:#333,stroke-width:2px
+```
 
-The Core Booth system is a modular and extensible framework for building and managing conversational AI agents, referred to as "Booths." It provides a structured way to define the capabilities, context, and tools for different AI-powered conversational flows.
+1.  **User Interface**: A frontend application (e.g., a Vue component) captures user input and displays the conversation.
+2.  **Service Layer (`useLLMService.ts`)**: This layer acts as a bridge between the UI and the Booths engine. It initializes the `CoreBooth`, manages the conversational state, and exposes methods for sending messages.
+3.  **`CoreBooth`**: The central orchestrator of the system. It is configured with an `LLMAdapter`, and a set of registries for booths, tools, and plugins.
+4.  **`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.
+5.  **`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.
+6.  **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.
+7.  **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).
 
-The system is designed around a central `CoreBooth` class that orchestrates interactions between users and the Large Language Model (LLM), leveraging a system of registries and plugins to manage the conversational state and capabilities.
+## Running the Examples
 
-## Installation
+The best way to understand the Booths framework is to run the example application provided in the `src/examples` directory.
 
-```bash
-npm install booths
-```
+### Prerequisites
+
+-   Node.js and npm installed.
+-   An OpenAI API key.
+
+### Setup
+
+1.  **Clone the repository:**
+    ```bash
+    git clone <repository-url>
+    cd booths
+    ```
+
+2.  **Install dependencies:**
+    ```bash
+    npm install
+    ```
 
-## Quick Start Example
+3.  **Set up your environment variables:**
+    Create a `.env.local` file in the root of the project and add your OpenAI API key:
+    ```
+    VITE_OPENAI_API_KEY=your-openai-api-key
+    ```
 
-Here is a lightweight example of how to set up and use the Core Booth system.
+4.  **Run the application:**
+    ```bash
+    npm run dev
+    ```
 
-### 1. Define Booths and Tools
+This will start a local development server. Open your browser to the specified address (usually `http://localhost:5173`) to see the chat application in action.
 
-First, define your booth configurations and any custom tools you need.
+The example application features a collection of pirate-themed booths that demonstrate how to create and manage different conversational agents. You can interact with a "Sea Lore" booth, a "Shipwright" booth, and even a "Duel" booth.
+
+## Quick Start Guide
+
+Here is a lightweight example of how to set up and use the Core Booth system manually.
+
+### 1. Define a Booth
+
+First, define a booth configuration. This object specifies the booth's identity, role, and the tools it can use.
 
 ```typescript
 // in my-booths.ts
 import type { BoothConfig } from 'booths';
 
-export const customerSupportBooth: BoothConfig = {
-  id: 'customer-support',
-  role: 'Customer Support Assistant',
-  description: 'You are a helpful customer support assistant for a SaaS company.',
-  tools: ['get_user_account_details'],
-  examples: ["I'm having trouble with my account.", 'I want to upgrade my subscription.'],
+export const pirateBooth: BoothConfig = {
+  id: 'pirate-booth',
+  role: 'You are a salty pirate captain.',
+  description: 'You speak like a pirate and can tell pirate jokes.',
+  tools: ['tell_pirate_joke'],
+  examples: ["Tell me a joke.", "Why are pirates called pirates?"],
 };
 ```
 
+### 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
 import type { ToolModule } from 'booths';
 
-export const getUserAccountDetailsTool: ToolModule = {
+export const tellPirateJokeTool: ToolModule = {
   type: 'function',
-  name: 'get_user_account_details',
-  description: 'Gets the account details for the current user.',
+  name: 'tell_pirate_joke',
+  description: 'Tells a classic pirate joke.',
   parameters: { type: 'object', properties: {} },
   execute: async () => {
-    // In a real app, you would fetch this from an API
-    return { accountId: '123', plan: 'Pro' };
+    return { joke: "Why are pirates called pirates? Because they arrrr!" };
   },
 };
 ```
 
-### 2. Implement the LLM Adapter
+### 3. Implement the LLM Adapter
 
-The `CoreBooth` requires an `LLMAdapter` to communicate with your chosen language model. Here is a minimal example of what that adapter could look like.
+The `CoreBooth` requires an `LLMAdapter` to communicate with your chosen language model. Here is a minimal example for OpenAI.
 
 ```typescript
-// in MyLLMAdapter.ts
-import type { LLMAdapter, ResponseCreateParamsNonStreaming } from 'booths';
-
-class MyLLMAdapter implements LLMAdapter<any> {
-    async createResponse(params: ResponseCreateParamsNonStreaming) {
-        // This is a mock implementation.
-        // In a real application, you would make a call to an LLM API (e.g., OpenAI, Anthropic).
-        console.log('Sending to LLM:', params.messages);
-        
-        const lastMessage = params.messages[params.messages.length - 1];
-
-        if (lastMessage.content?.includes("check my account plan")) {
-             return {
-                id: 'fake-response-id',
-                choices: [{
-                    message: {
-                        role: 'assistant',
-                        content: null,
-                        tool_calls: [{
-                            id: 'tool-call-1',
-                            type: 'function',
-                            function: {
-                                name: 'get_user_account_details',
-                                arguments: '{}'
-                            }
-                        }]
-                    }
-                }]
-             }
-        }
-        
-        return {
-            id: 'fake-response-id',
-            choices: [{
-                message: {
-                    role: 'assistant',
-                    content: "I am on the Pro plan.",
-                }
-            }]
-        };
-    }
-}
+// in openAIAdapter.ts
+import type { LLMAdapter, ResponseCreateParamsNonStreaming, Response } from 'booths';
+import openai from 'openai';
+
+export class OpenAIAdapter implements LLMAdapter<any> {
+  openai: openai;
 
-export default MyLLMAdapter;
+  constructor(apiKey: string) {
+    this.openai = new openai({ apiKey, dangerouslyAllowBrowser: true });
+  }
+
+  invoke(params: ResponseCreateParamsNonStreaming) {
+    return this.openai.responses.create({ ...params, model: 'gpt-4o' });
+  }
+
+  async interpret(response: Response): Promise<Response> {
+    return response;
+  }
+}
 ```
 
-### 3. Initialize the CoreBooth
+### 4. Initialize the CoreBooth
 
-Next, instantiate the registries and the `CoreBooth` itself.
+Finally, use the `createCoreBooth` factory to instantiate the system.
 
 ```typescript
 // in main.ts
-import { CoreBooth, BoothRegistry, ToolRegistry, BoothPluginRegistry } from 'booths';
-import { customerSupportBooth } from './my-booths';
-import { getUserAccountDetailsTool } from './my-tools';
-import MyLLMAdapter from './MyLLMAdapter';
-
-// 1. Create instances of the registries
-const boothRegistry = new BoothRegistry();
-const toolRegistry = new ToolRegistry();
-const boothPluginRegistry = new BoothPluginRegistry(); // For custom user plugins
-
-// 2. Register your booths and tools
-boothRegistry.registerBooths([customerSupportBooth]);
-toolRegistry.registerTools([getUserAccountDetailsTool]);
-
-// 3. Set a starting context for the conversation
-boothRegistry.setCurrentContextId('customer-support');
-
-// 4. Create the CoreBooth instance with the adapter
-const coreBooth = new CoreBooth({
-  booths: boothRegistry,
-  tools: toolRegistry,
-  boothPlugins: boothPluginRegistry,
-  llmAdapter: new MyLLMAdapter(),
-});
-
-// 5. Send a message and get a response
+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);
+
+// 3. Register the tool (this step will be improved in future versions)
+coreBooth.toolRegistry.registerTools([tellPirateJokeTool]);
+
+// 4. Send a message and get a response
 async function haveConversation() {
-  const userInput = 'Can you check my account plan?';
+  const userInput = 'Tell me a pirate joke.';
   const response = await coreBooth.callProcessor.send(userInput);
 
   console.log(response.output_text);
-  // Expected output might be something like: "You are currently on the Pro plan."
+  // Expected output: "Why are pirates called pirates? Because they arrrr!"
 }
 
 haveConversation();
 ```
-
 ## How It Works
 
 The Core Booth system is comprised of several key components that work together to process user input and generate contextual responses.

package/dist/index.d.ts

@@ -37,7 +37,7 @@ export declare interface BoothConfig {
     /** The developer or team responsible for the booth. */
     developer?: string;
     /** A list of tool names that this booth is authorized to use. */
-    tools: string[];
+    tools?: string[];
     /**
      * A list of tools in the format expected by the Multi-Category Peppercorn (MCP) system.
      * This is likely for more complex tool definitions.
@@ -51,7 +51,7 @@ export declare interface BoothConfig {
      */
     responseFormat?: string;
     /** A list of example queries or inputs that the booth is designed to handle. */
-    examples: string[];
+    examples?: string[];
     /**
      * Defines fallback behavior for when the booth receives a query that is out of scope.
      */
@@ -121,7 +121,7 @@ export declare interface BoothPlugin {
      * @param context - Context information about the tool call execution.
      * @returns The potentially modified tool call result.
      */
-    onAfterToolCall?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, result: any, context: ToolCallContext) => Promise<any>;
+    onAfterToolCall?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, result: unknown, context: ToolCallContext) => Promise<unknown>;
     /**
      * Called when an individual tool call encounters an error during execution.
      * This allows for custom error handling or recovery.
@@ -131,7 +131,7 @@ export declare interface BoothPlugin {
      * @param context - Context information about the tool call execution.
      * @returns The error result or a recovery value to use instead.
      */
-    onToolCallError?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, error: Error, context: ToolCallContext) => Promise<any>;
+    onToolCallError?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, error: Error, context: ToolCallContext) => Promise<unknown>;
     /**
      * Determines whether the interaction loop should end. This is a mandatory method
      * for all plugins.
@@ -372,6 +372,11 @@ export declare class BoothRegistry {
      * @returns Record of all booth configurations indexed by their IDs
      */
     getAllBooths(): Record<string, BoothConfig>;
+    /**
+     * Checks if the registry is operating in a multi-booth configuration.
+     * @returns {boolean} `true` if there is more than one booth registered, otherwise `false`.
+     */
+    get isMultiBoothMode(): boolean;
     /**
      * Removes a booth configuration from the registry by its ID.
      * Throws an error if the booth doesn't exist.
@@ -457,6 +462,7 @@ export declare class ConversationHistoryPlugin implements BoothPlugin {
      * @private
      */
     private readonly plugin_description;
+    private responseContainsBoothChange;
     /**
      * Returns the plugin's unique identifier.
      */
@@ -487,7 +493,7 @@ export declare class ConversationHistoryPlugin implements BoothPlugin {
      * @param response
      * @returns Unmodified response parameters
      */
-    onResponseReceived(_: RepositoryUtilities, responseParams: ResponseCreateParamsNonStreaming, response: Response_2): Promise<{
+    onResponseReceived(utilities: RepositoryUtilities, responseParams: ResponseCreateParamsNonStreaming, response: Response_2): Promise<{
         input: ( ResponseFunctionToolCall | EasyInputMessage | ResponseOutputMessage | ResponseFileSearchToolCall | ResponseComputerToolCall | ResponseInputItem.ComputerCallOutput | ResponseFunctionWebSearch | ResponseInputItem.FunctionCallOutput | ResponseReasoningItem | ResponseInputItem.ImageGenerationCall | ResponseCodeInterpreterToolCall | ResponseInputItem.LocalShellCall | ResponseInputItem.LocalShellCallOutput | ResponseInputItem.McpListTools | ResponseInputItem.McpApprovalRequest | ResponseInputItem.McpApprovalResponse | ResponseInputItem.McpCall | ResponseInputItem.ItemReference)[];
         stream?: false | null;
         background?: boolean | null;
@@ -586,6 +592,17 @@ export declare class CoreBooth<T> {
     });
 }
 
+/**
+ * Creates a new instance of CoreBooth configured for a single booth.
+ * This factory simplifies the setup of a CoreBooth by managing the
+ * instantiation of the necessary registries.
+ *
+ * @param llmAdapter - The LLM adapter for communication with the language model.
+ * @param boothConfig - The configuration for the single booth to be used.
+ * @returns A fully configured CoreBooth instance.
+ */
+export declare function createCoreBooth<T>(llmAdapter: LLMAdapter<T>, boothConfig: BoothConfig): CoreBooth<T>;
+
 /**
  * Creates a `route_to_booth` tool module that can be used by the LLM to switch the conversation
  * context to a different booth. The tool's definition is dynamically generated based on the
@@ -691,7 +708,7 @@ export declare class InteractionProcessor<T> {
      * @param boothRegistry - The registry for booth configurations.
      * @param boothPlugins - The registry for booth plugins.
      * @param toolRegistry - The registry for available tools.
-     * @param openAIClient - The OpenAI client instance.
+     * @param llmAdapter - The adapter for interacting with the LLM.
      */
     constructor(boothRegistry: BoothRegistry, boothPlugins: BoothPluginRegistry, toolRegistry: ToolRegistry, llmAdapter: LLMAdapter<T>);
     /**
@@ -725,6 +742,8 @@ export declare type RepositoryUtilities = {
     toolRegistry: ToolRegistry;
     /** An instance of the BoothPluginRegistry for managing and coordinating plugins. */
     pluginRegistry: BoothPluginRegistry;
+    /** An instance of the LLMAdapter for direct interaction with the Language Model. */
+    llmAdapter: LLMAdapter<unknown>;
 };
 
 export { ResponseCreateParamsNonStreaming }
@@ -776,7 +795,7 @@ export declare class ToolExecutorPlugin implements BoothPlugin {
      * @param utilities - Repository utilities for accessing registries.
      * @param toolCall - The tool call to execute.
      * @param context - Context information about the tool call execution.
-     * @returns The function call output item for the response.
+     * @returns The function calls output item for the response.
      * @private
      */
     private executeToolCall;

package/dist/index.js

@@ -1,9 +1,14 @@
-class g {
-  /**
-   * Collection of registered plugins.
-   * @private
-   */
-  plugins = [];
+var _ = Object.defineProperty;
+var B = (i, t, o) => t in i ? _(i, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : i[t] = o;
+var s = (i, t, o) => B(i, typeof t != "symbol" ? t + "" : t, o);
+class R {
+  constructor() {
+    /**
+     * Collection of registered plugins.
+     * @private
+     */
+    s(this, "plugins", []);
+  }
   /**
    * Registers a single plugin in the registry.
    * Throws an error if a plugin with the same ID already exists.
@@ -111,7 +116,11 @@ class g {
    */
   async runShouldEndInteractionLoop(t, o, e) {
     for (const r of this.plugins)
-      if (await r.shouldEndInteractionLoop(t, o, e))
+      if (await r.shouldEndInteractionLoop(
+        t,
+        o,
+        e
+      ))
         return !0;
     return !1;
   }
@@ -158,8 +167,8 @@ class g {
    */
   async runAfterToolCall(t, o, e, r) {
     let n = e;
-    for (const s of this.plugins)
-      s.onAfterToolCall && (n = await s.onAfterToolCall(t, o, n, r));
+    for (const l of this.plugins)
+      l.onAfterToolCall && (n = await l.onAfterToolCall(t, o, n, r));
     return n;
   }
   /**
@@ -175,31 +184,31 @@ class g {
    */
   async runToolCallError(t, o, e, r) {
     let n = `Error: ${e.message}`;
-    for (const s of this.plugins)
-      s.onToolCallError && (n = await s.onToolCallError(t, o, e, r));
+    for (const l of this.plugins)
+      l.onToolCallError && (n = await l.onToolCallError(t, o, e, r));
     return n;
   }
 }
-class b {
+class T {
   /**
    * Creates a new booth registry with a specified base booth configuration.
    *
    * @param baseBooth - The base booth configuration that all other booths extend from
    * @param currentContextId - The initial current context booth ID (default is 'orchestrator')
    */
-  constructor(t, o = "orchestrator") {
-    this.baseBooth = t, this.currentContextId = o;
+  constructor(t, o) {
+    /**
+     * Collection of registered booth configurations, indexed by their IDs.
+     * @private
+     */
+    s(this, "booths", {});
+    /**
+     * The current context booth ID, defaulting to the orchestrator context.
+     * @private
+     */
+    s(this, "currentContextId");
+    this.baseBooth = t, this.registerBooth(t), this.currentContextId = o || t.id;
   }
-  /**
-   * Collection of registered booth configurations, indexed by their IDs.
-   * @private
-   */
-  booths = {};
-  /**
-   * The current context booth ID, defaulting to the orchestrator context.
-   * @private
-   */
-  currentContextId;
   /**
    * Gets the current context booth ID.
    *
@@ -238,9 +247,7 @@ class b {
    * @param boothConfig - The booth configuration to register
    */
   registerBooth(t) {
-    if (this.booths[t.id])
-      throw new Error(`Booth with ID ${t.id} is already registered.`);
-    this.booths[t.id] = t;
+    this.booths[t.id] || (this.booths[t.id] = t);
   }
   /**
    * Returns the base booth configuration that was provided during initialization.
@@ -290,6 +297,13 @@ class b {
   getAllBooths() {
     return this.booths;
   }
+  /**
+   * Checks if the registry is operating in a multi-booth configuration.
+   * @returns {boolean} `true` if there is more than one booth registered, otherwise `false`.
+   */
+  get isMultiBoothMode() {
+    return Object.keys(this.booths).length > 1;
+  }
   /**
    * Removes a booth configuration from the registry by its ID.
    * Throws an error if the booth doesn't exist.
@@ -302,18 +316,18 @@ class b {
     delete this.booths[t];
   }
 }
-class d {
+class E {
   /**
    * Creates an instance of InteractionProcessor.
    * @param boothRegistry - The registry for booth configurations.
    * @param boothPlugins - The registry for booth plugins.
    * @param toolRegistry - The registry for available tools.
-   * @param openAIClient - The OpenAI client instance.
+   * @param llmAdapter - The adapter for interacting with the LLM.
    */
   constructor(t, o, e, r) {
+    s(this, "loopLimit", 10);
     this.boothRegistry = t, this.boothPlugins = o, this.toolRegistry = e, this.llmAdapter = r;
   }
-  loopLimit = 10;
   /**
    * Creates a synthetic error response with proper structure and error details.
    * @param error - The error that occurred
@@ -389,14 +403,16 @@ class d {
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins
+          pluginRegistry: this.boothPlugins,
+          llmAdapter: this.llmAdapter
         },
         e
       ), r = await this.callLLM(e), e = await this.boothPlugins.runResponseReceived(
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins
+          pluginRegistry: this.boothPlugins,
+          llmAdapter: this.llmAdapter
         },
         e,
         r
@@ -404,7 +420,8 @@ class d {
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins
+          pluginRegistry: this.boothPlugins,
+          llmAdapter: this.llmAdapter
         },
         e,
         r
@@ -433,7 +450,8 @@ class d {
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
-        pluginRegistry: this.boothPlugins
+        pluginRegistry: this.boothPlugins,
+        llmAdapter: this.llmAdapter
       },
       o,
       t
@@ -443,29 +461,87 @@ class d {
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
-        pluginRegistry: this.boothPlugins
+        pluginRegistry: this.boothPlugins,
+        llmAdapter: this.llmAdapter
       },
       e
     ), e;
   }
 }
-let a = [];
-class p {
-  /**
-   * Unique identifier for this plugin instance.
-   * @private
-   */
-  plugin_id = "conversation-history";
-  /**
-   * Display name for this plugin.
-   * @private
-   */
-  plugin_name = "Conversation History Plugin";
-  /**
-   * Brief description of the plugin's purpose and functionality.
-   * @private
-   */
-  plugin_description = "A plugin to manage conversation history in booths.";
+const C = {
+  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."
+}, d = "route_to_booth";
+function w(i) {
+  const t = i.getAllBooths(), o = Object.values(t).map(
+    (r) => `- ${r.id}: ${r.role}
+  Examples:
+${(r.examples || []).map((n) => `    - "${n}"`).join(`
+`)}`
+  ).join(`
+`), e = Object.keys(t);
+  return {
+    type: "function",
+    name: d,
+    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,
+    /**
+     * Executes the tool's logic, which sets the current context in the `boothRegistry`
+     * to the specified `targetBooth`.
+     * @param targetBooth - The ID of the booth to switch to.
+     * @returns An object with a `content` property indicating the result of the operation.
+     */
+    execute: async function({ targetBooth: r }) {
+      try {
+        return i.setCurrentContextId(r), {
+          content: `Routed to booth ${r}`
+        };
+      } catch (n) {
+        return console.error("[routeToBoothTool] Error routing to booth:", n), {
+          content: `Error: Unable to route to booth ${r}.`
+        };
+      }
+    }
+  };
+}
+let c = [];
+class I {
+  constructor() {
+    /**
+     * Unique identifier for this plugin instance.
+     * @private
+     */
+    s(this, "plugin_id", "conversation-history");
+    /**
+     * Display name for this plugin.
+     * @private
+     */
+    s(this, "plugin_name", "Conversation History Plugin");
+    /**
+     * Brief description of the plugin's purpose and functionality.
+     * @private
+     */
+    s(this, "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 === d : o.type === "message" && "tool_calls" in o && Array.isArray(o.tool_calls) ? o.tool_calls.some(
+      (e) => e.type === "function" && e.function.name === d
+    ) : !1) : !1;
+  }
   /**
    * Returns the plugin's unique identifier.
    */
@@ -494,9 +570,9 @@ class p {
    */
   async onBeforeInteractionLoopStart(t, o) {
     const { input: e } = o, r = typeof e == "string" ? [{ role: "user", content: e }] : e || [];
-    return a.push(...r), {
+    return c.push(...r), {
       ...o,
-      input: a
+      input: c
     };
   }
   /**
@@ -509,8 +585,20 @@ class p {
    * @returns Unmodified response parameters
    */
   async onResponseReceived(t, o, e) {
-    const n = [...o.input, ...e?.output ?? []];
-    return a = n, {
+    let n = [...o.input, ...(e == null ? void 0 : e.output) ?? []];
+    if (this.responseContainsBoothChange(e)) {
+      const a = `Please summarize the following conversation history:
+
+${JSON.stringify(c)}`, g = (await S(t.llmAdapter, C).callProcessor.send(a)).output_text, f = n.filter((h) => "role" in h && h.role === "user").pop(), y = {
+        role: "developer",
+        content: `A conversation summary up to this point: ${g}`
+      }, m = n.filter(
+        (h) => "type" in h && h.type === "function_call" || h.type === "function_call_output"
+      );
+      c = f ? [...m, y, f] : [...m, y], n = c;
+    } else
+      c = n;
+    return {
       ...o,
       input: n
     };
@@ -525,22 +613,24 @@ class p {
     return !1;
   }
 }
-class f {
-  /**
-   * Unique identifier for this plugin instance.
-   * @private
-   */
-  plugin_id = "context-provider";
-  /**
-   * Display the name for this plugin.
-   * @private
-   */
-  plugin_name = "Context Provider Plugin";
-  /**
-   * Brief description of the plugin's purpose and functionality.
-   * @private
-   */
-  plugin_description = "A plugin to provide context to booths.";
+class v {
+  constructor() {
+    /**
+     * Unique identifier for this plugin instance.
+     * @private
+     */
+    s(this, "plugin_id", "context-provider");
+    /**
+     * Display the name for this plugin.
+     * @private
+     */
+    s(this, "plugin_name", "Context Provider Plugin");
+    /**
+     * Brief description of the plugin's purpose and functionality.
+     * @private
+     */
+    s(this, "plugin_description", "A plugin to provide context to booths.");
+  }
   /**
    * Returns the plugin's unique identifier.
    */
@@ -568,11 +658,17 @@ class f {
    * @returns Updated response parameters with added instructions containing booth context
    */
   async onBeforeMessageSend(t, o) {
-    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig;
-    let n = e.description;
-    return n += `
+    const e = t.boothRegistry;
+    let n = e.baseBoothConfig.description;
+    if (e.isMultiBoothMode) {
+      const l = e.orchestratorBoothConfig, a = e.currentContextBoothConfig;
+      n += `
+
+ ${l.description}`, a.id !== l.id && (n += `
 
- ${r.description}`, { ...o, instructions: n };
+ ${a.description}`);
+    }
+    return { ...o, instructions: n };
   }
   /**
    * Determines whether the interaction loop should end.
@@ -584,12 +680,12 @@ class f {
     return !1;
   }
 }
-class m {
-  tools;
+class A {
   /**
    * Initializes an empty Map to store tools.
    */
   constructor() {
+    s(this, "tools");
     this.tools = /* @__PURE__ */ new Map();
   }
   registerTools(t) {
@@ -640,10 +736,12 @@ class m {
     this.tools.delete(t);
   }
 }
-class y {
-  description = "A plugin to aggregate and provide tools from base and context booths.";
-  id = "tool-provider";
-  name = "Tool Provider Plugin";
+class P {
+  constructor() {
+    s(this, "description", "A plugin to aggregate and provide tools from base and context booths.");
+    s(this, "id", "tool-provider");
+    s(this, "name", "Tool Provider Plugin");
+  }
   /**
    * Before a message is sent, this hook gathers the tool keys from both the base and context booths,
    * retrieves the corresponding tool definitions from the `toolRegistry`, and adds them to the
@@ -653,18 +751,22 @@ class y {
    * @returns The updated response parameters with the aggregated list of tools.
    */
   async onBeforeMessageSend(t, o) {
-    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, n = [...e.tools || [], ...r?.tools || []], s = /* @__PURE__ */ new Set();
+    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, n = [...e.tools || [], ...(r == null ? void 0 : r.tools) || []], l = /* @__PURE__ */ new Set();
     for (const u of n) {
-      if (s.has(u))
+      if (l.has(u))
         throw new Error(`Duplicate tool key detected: ${u}`);
-      s.add(u);
+      l.add(u);
     }
-    const l = n.map(
+    const a = n.map(
       (u) => t.toolRegistry.getTool(u)
     );
-    return e.mcp && l.push(...e.mcp), r?.mcp && l.push(...r.mcp), {
+    if (e.mcp && a.push(...e.mcp), r != null && r.mcp && a.push(...r.mcp), t.boothRegistry.isMultiBoothMode) {
+      const u = w(t.boothRegistry);
+      a.push(u);
+    }
+    return {
       ...o,
-      tools: l
+      tools: a
     };
   }
   /**
@@ -676,16 +778,18 @@ class y {
     return !1;
   }
 }
-class w {
-  id = "tool-executor";
-  name = "Tool Executor";
-  description = "Checks for tool calls in the response, executes them, and adds the results to the message history.";
+class x {
+  constructor() {
+    s(this, "id", "tool-executor");
+    s(this, "name", "Tool Executor");
+    s(this, "description", "Checks for tool calls in the response, executes them, and adds the results to the message history.");
+  }
   /**
    * Executes a single tool call with proper hook integration.
    * @param utilities - Repository utilities for accessing registries.
    * @param toolCall - The tool call to execute.
    * @param context - Context information about the tool call execution.
-   * @returns The function call output item for the response.
+   * @returns The function calls output item for the response.
    * @private
    */
   async executeToolCall(t, o, e) {
@@ -701,16 +805,16 @@ class w {
           call_id: r.call_id,
           output: `Error: Tool '${r.name}' not found.`
         };
-      const s = await n.execute(JSON.parse(r.arguments)), l = await t.pluginRegistry.runAfterToolCall(
+      const l = await n.execute(JSON.parse(r.arguments)), a = await t.pluginRegistry.runAfterToolCall(
         t,
         r,
-        s,
+        l,
         e
       );
       return {
         type: "function_call_output",
         call_id: r.call_id,
-        output: JSON.stringify(l)
+        output: JSON.stringify(a)
       };
     } catch (r) {
       console.error(`Error executing tool ${o.name}:`, r);
@@ -737,24 +841,24 @@ class w {
    * @returns The updated response parameters, potentially with tool call outputs added to the input.
    */
   async onResponseReceived(t, o, e) {
-    const n = (e?.output ?? [])?.filter(
-      (l) => l.type === "function_call"
-    ) ?? [];
+    const r = (e == null ? void 0 : e.output) ?? [], n = (r == null ? void 0 : r.filter(
+      (a) => a.type === "function_call"
+    )) ?? [];
     if (!n.length)
       return o;
-    const s = [];
-    for (let l = 0; l < n.length; l++) {
-      const u = n[l], c = {
+    const l = [];
+    for (let a = 0; a < n.length; a++) {
+      const u = n[a], p = {
         responseParams: o,
         response: e,
-        toolCallIndex: l,
+        toolCallIndex: a,
         totalToolCalls: n.length
-      }, h = await this.executeToolCall(t, u, c);
-      s.push(h);
+      }, g = await this.executeToolCall(t, u, p);
+      l.push(g);
     }
     return {
       ...o,
-      input: [...o.input, ...s]
+      input: [...o.input, ...l]
     };
   }
   /**
@@ -766,55 +870,12 @@ class w {
     return !1;
   }
 }
-function _(i) {
-  const t = i.getAllBooths(), o = Object.values(t).map(
-    (r) => `- ${r.id}: ${r.role}
-  Examples:
-${r.examples.map((n) => `    - "${n}"`).join(`
-`)}`
-  ).join(`
-`), e = Object.keys(t);
-  return {
-    type: "function",
-    name: "route_to_booth",
-    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,
-    /**
-     * Executes the tool's logic, which sets the current context in the `boothRegistry`
-     * to the specified `targetBooth`.
-     * @param targetBooth - The ID of the booth to switch to.
-     * @returns An object with a `content` property indicating the result of the operation.
-     */
-    execute: async function({ targetBooth: r }) {
-      try {
-        return i.setCurrentContextId(r), {
-          content: `Routed to booth ${r}`
-        };
-      } catch (n) {
-        return console.error("[routeToBoothTool] Error routing to booth:", n), {
-          content: `Error: Unable to route to booth ${r}.`
-        };
-      }
-    }
-  };
-}
-class R {
-  description = "A plugin to ensure the interaction loop can be finished.";
-  id = "finish-turn-plugin";
-  name = "Finish Turn Plugin";
+class L {
+  constructor() {
+    s(this, "description", "A plugin to ensure the interaction loop can be finished.");
+    s(this, "id", "finish-turn-plugin");
+    s(this, "name", "Finish Turn Plugin");
+  }
   /**
    * Before sending a message, this hook adds an instruction to the LLM to include a
    * specific marker (`__awaiting_user_response__`) when it expects a user response.
@@ -830,7 +891,7 @@ class R {
  
     [MUST]
     - Add the marker "__awaiting_user_response__" to the end of your response when you expect a user response.
-    - This marker indicates that the interaction loop should end and the system should wait for user input
+    - This marker indicates that the interaction loop should end and the system should wait for user input.
     - If the marker is not present, the system will continue to process the response as usual.
     `, {
       ...o,
@@ -867,51 +928,51 @@ class R {
     return o;
   }
 }
-class B {
-  /**
-   * Represents a registry that maintains a collection of plugins for a booth system.
-   * The boothPluginRegistry is used to manage and access plugins that enhance
-   * or extend the booth's behavior or features.
-   *
-   * This variable is intended to provide a central location for plugin registration,
-   * retrieval, and management.
-   *
-   * @type {BoothPluginRegistry}
-   */
-  boothPluginRegistry;
-  /**
-   * Registry for managing booth configurations across the system.
-   * This registry maintains a collection of booth definitions that can be
-   * accessed by their unique identifiers.
-   *
-   * @type {BoothRegistry}
-   */
-  boothRegistry;
-  /**
-   * Primary processor for handling interactions between users and the booth system.
-   * Responsible for sending messages to the LLM, processing responses, and managing
-   * the interaction loop through plugins.
-   *
-   * @type {InteractionProcessor}
-   */
-  callProcessor;
-  /**
-   * Registry dedicated to system-level plugins that are always available.
-   * This includes core functionality plugins like conversation history and context providers,
-   * as well as any user-defined plugins from the boothPluginRegistry.
-   *
-   * @type {BoothPluginRegistry}
-   */
-  systemPluginsRegistry;
-  /**
-   * A variable that represents a registry for managing and maintaining a collection of tools.
-   * `toolRegistry` is an instance of the `ToolRegistry` class, which provides functionalities
-   * for adding, removing, and retrieving tools.
-   *
-   * The `ToolRegistry` class typically serves as a centralized storage or management
-   * solution for tools that are used in a specific context or application.
-   */
-  toolRegistry;
+const b = {
+  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
+  `
+};
+function S(i, t) {
+  const o = new T(t), e = new A(), r = new R();
+  return new M({
+    llmAdapter: i,
+    booths: o,
+    tools: e,
+    boothPlugins: r
+  });
+}
+class M {
   /**
    * Initializes a new instance of the CoreBooth class.
    * Sets up the plugin registries, system plugins, and interaction processor.
@@ -922,15 +983,62 @@ class B {
    * @param {ToolRegistry} options.tools - Registry containing tool configurations
    */
   constructor(t) {
-    this.boothPluginRegistry = t.boothPlugins, this.boothRegistry = t.booths, this.toolRegistry = t.tools;
-    const o = _(this.boothRegistry);
-    this.toolRegistry.registerTools([o]), this.systemPluginsRegistry = new g(), this.systemPluginsRegistry.registerPlugins([
-      new p(),
-      new f(),
-      new y(),
-      new w(),
-      new R()
-    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new d(
+    /**
+     * Represents a registry that maintains a collection of plugins for a booth system.
+     * The boothPluginRegistry is used to manage and access plugins that enhance
+     * or extend the booth's behavior or features.
+     *
+     * This variable is intended to provide a central location for plugin registration,
+     * retrieval, and management.
+     *
+     * @type {BoothPluginRegistry}
+     */
+    s(this, "boothPluginRegistry");
+    /**
+     * Registry for managing booth configurations across the system.
+     * This registry maintains a collection of booth definitions that can be
+     * accessed by their unique identifiers.
+     *
+     * @type {BoothRegistry}
+     */
+    s(this, "boothRegistry");
+    /**
+     * Primary processor for handling interactions between users and the booth system.
+     * Responsible for sending messages to the LLM, processing responses, and managing
+     * the interaction loop through plugins.
+     *
+     * @type {InteractionProcessor}
+     */
+    s(this, "callProcessor");
+    /**
+     * Registry dedicated to system-level plugins that are always available.
+     * This includes core functionality plugins like conversation history and context providers,
+     * as well as any user-defined plugins from the boothPluginRegistry.
+     *
+     * @type {BoothPluginRegistry}
+     */
+    s(this, "systemPluginsRegistry");
+    /**
+     * A variable that represents a registry for managing and maintaining a collection of tools.
+     * `toolRegistry` is an instance of the `ToolRegistry` class, which provides functionalities
+     * for adding, removing, and retrieving tools.
+     *
+     * The `ToolRegistry` class typically serves as a centralized storage or management
+     * solution for tools that are used in a specific context or application.
+     */
+    s(this, "toolRegistry");
+    if (this.boothPluginRegistry = t.boothPlugins, this.boothRegistry = t.booths, this.toolRegistry = t.tools, this.boothRegistry.isMultiBoothMode) {
+      this.boothRegistry.registerBooth(b), this.boothRegistry.setCurrentContextId(b.id);
+      const o = w(this.boothRegistry);
+      this.toolRegistry.registerTools([o]);
+    }
+    this.systemPluginsRegistry = new R(), this.systemPluginsRegistry.registerPlugins([
+      new I(),
+      new v(),
+      new P(),
+      new x(),
+      new L()
+    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new E(
       this.boothRegistry,
       this.systemPluginsRegistry,
       this.toolRegistry,
@@ -939,15 +1047,16 @@ class B {
   }
 }
 export {
-  g as BoothPluginRegistry,
-  b as BoothRegistry,
-  f as ContextProviderPlugin,
-  p as ConversationHistoryPlugin,
-  B as CoreBooth,
-  R as FinishTurnPlugin,
-  d as InteractionProcessor,
-  w as ToolExecutorPlugin,
-  y as ToolProviderPlugin,
-  m as ToolRegistry,
-  _ as createRouteToBoothTool
+  R as BoothPluginRegistry,
+  T as BoothRegistry,
+  v as ContextProviderPlugin,
+  I as ConversationHistoryPlugin,
+  M as CoreBooth,
+  L as FinishTurnPlugin,
+  E as InteractionProcessor,
+  x as ToolExecutorPlugin,
+  P as ToolProviderPlugin,
+  A as ToolRegistry,
+  S as createCoreBooth,
+  w as createRouteToBoothTool
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "booths",
   "private": false,
-  "version": "0.0.6",
+  "version": "0.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -18,18 +18,25 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "format": "prettier --write \"src/**/*.{js,ts,vue,json,css,scss,md}\""
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",
     "@types/node": "^24.0.11",
+    "@vitejs/plugin-vue": "^5.2.4",
+    "@vue/eslint-config-prettier": "^10.2.0",
+    "dotenv": "^17.2.0",
     "eslint": "^9.30.1",
-    "openai": "^5.8.2",
+    "eslint-config-prettier": "^10.1.5",
+    "openai": "^5.9.0",
+    "prettier": "^3.6.2",
     "typescript": "~5.8.3",
     "typescript-eslint": "^8.36.0",
-    "vite": "^7.0.3",
+    "vite": "^6.3.5",
     "vite-plugin-dts": "^4.5.4",
-    "vite-tsconfig-paths": "^5.1.4"
+    "vite-tsconfig-paths": "^5.1.4",
+    "vue": "^3.5.17"
   },
   "peerDependencies": {
     "openai": "^5.8.2"