booths 0.0.0

package/dist/index.js

@@ -0,0 +1,946 @@
+class g {
+  /**
+   * Collection of registered plugins.
+   * @private
+   */
+  plugins = [];
+  /**
+   * Registers a single plugin in the registry.
+   * Throws an error if a plugin with the same ID already exists.
+   *
+   * @param plugin - The plugin instance to register
+   */
+  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);
+  }
+  /**
+   * Returns all registered plugins.
+   *
+   * @returns Array of registered plugin instances
+   */
+  getPlugins() {
+    return this.plugins;
+  }
+  /**
+   * Registers multiple plugins at once.
+   *
+   * @param plugins - Array of plugin instances to register
+   */
+  registerPlugins(t) {
+    for (const o of t)
+      this.registerPlugin(o);
+  }
+  /**
+   * Finds and returns a plugin by its ID.
+   *
+   * @param pluginId - The unique identifier of the plugin to retrieve
+   * @returns The plugin instance if found, undefined otherwise
+   */
+  getPluginById(t) {
+    return this.plugins.find((o) => o.id === t);
+  }
+  /**
+   * Removes a plugin from the registry by its ID.
+   * Throws an error if the plugin doesn't exist.
+   *
+   * @param pluginId - The unique identifier of the plugin to remove
+   */
+  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);
+  }
+  /**
+   * Sequentially invokes every plugin's onBeforeInteractionLoopStart hook.
+   * Each plugin receives the accumulated response parameters from previous plugins,
+   * allowing them to build upon each other's modifications.
+   *
+   * @param prepareArgs - Context information including booth registry and current booth ID
+   * @param initialParams - Initial response parameters to be modified by plugins
+   * @param initialInput
+   * @returns Modified response parameters after all plugins have processed them
+   */
+  async runBeforeInteractionLoopStart(t, o, e) {
+    let r = o;
+    for (const n of this.plugins)
+      n.onBeforeInteractionLoopStart && (r = await n.onBeforeInteractionLoopStart(t, r, e));
+    return r;
+  }
+  /**
+   * Sequentially invokes every plugin's onBeforeMessageSend hook.
+   * This is called immediately before sending a message to the LLM,
+   * allowing plugins to modify the request parameters.
+   *
+   * @param prepareArgs - Context information including booth registry and current booth ID
+   * @param initialParams - Response parameters to be modified before sending to LLM
+   * @returns Modified response parameters after all plugins have processed them
+   */
+  async runBeforeMessageSend(t, o) {
+    let e = o;
+    for (const r of this.plugins)
+      r.onBeforeMessageSend && (e = await r.onBeforeMessageSend(t, e));
+    return e;
+  }
+  /**
+   * Sequentially invokes every plugin's onResponseReceived hook.
+   * This is called after receiving a response from the LLM,
+   * allowing plugins to process or modify the response.
+   *
+   * @param messageArgs - Context information including the LLM response, booth registry, and current booth ID
+   * @param initialParams - Response parameters to be potentially modified based on the received response
+   * @param response - The actual response received from the LLM
+   * @returns Modified response parameters after all plugins have processed them
+   */
+  async runResponseReceived(t, o, e) {
+    let r = o;
+    for (const n of this.plugins)
+      n.onResponseReceived && (r = await n.onResponseReceived(t, r, e));
+    return r;
+  }
+  /**
+   * Checks if any plugin wants to end the interaction loop.
+   * Returns true as soon as any plugin indicates the loop should end.
+   *
+   * @param prepareArgs - Context information including booth registry and current booth ID
+   * @param responseParams - Current response parameters
+   * @param response - The response received from the LLM
+   * @returns True if any plugin indicates the loop should end, false otherwise
+   */
+  async runShouldEndInteractionLoop(t, o, e) {
+    for (const r of this.plugins)
+      if (await r.shouldEndInteractionLoop(t, o, e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Sequentially invokes every plugin's onAfterInteractionLoopEnd hook.
+   * This is called when the interaction loop has completed,
+   * allowing plugins to perform cleanup or final processing.
+   *
+   * @param endArgs - Context information including booth registry and current booth ID
+   * @param finalResponse - The final response from the LLM
+   */
+  async runAfterInteractionLoopEnd(t, o) {
+    let e = o;
+    for (const r of this.plugins)
+      r.onAfterInteractionLoopEnd && (e = await r.onAfterInteractionLoopEnd(t, o));
+    return e;
+  }
+  /**
+   * Sequentially invokes every plugin's onBeforeToolCall hook.
+   * This is called before executing an individual tool call,
+   * allowing plugins to modify the tool call parameters.
+   *
+   * @param utilities - Context information including booth and tool registries
+   * @param toolCall - The tool call that is about to be executed
+   * @param context - Context information about the tool call execution
+   * @returns Modified tool call after all plugins have processed it
+   */
+  async runBeforeToolCall(t, o, e) {
+    let r = o;
+    for (const n of this.plugins)
+      n.onBeforeToolCall && (r = await n.onBeforeToolCall(t, r, e));
+    return r;
+  }
+  /**
+   * Sequentially invokes every plugin's onAfterToolCall hook.
+   * This is called after successfully executing an individual tool call,
+   * allowing plugins to process or modify the tool call result.
+   *
+   * @param utilities - Context information including booth and tool registries
+   * @param toolCall - The tool call that was executed
+   * @param result - The result returned by the tool execution
+   * @param context - Context information about the tool call execution
+   * @returns Modified result after all plugins have processed it
+   */
+  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));
+    return n;
+  }
+  /**
+   * Sequentially invokes every plugin's onToolCallError hook.
+   * This is called when an individual tool call encounters an error during execution,
+   * allowing plugins to handle or recover from the error.
+   *
+   * @param utilities - Context information including booth and tool registries
+   * @param toolCall - The tool call that failed
+   * @param error - The error that occurred during tool execution
+   * @param context - Context information about the tool call execution
+   * @returns Error result or recovery value after all plugins have processed it
+   */
+  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));
+    return n;
+  }
+}
+class b {
+  /**
+   * 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;
+  }
+  /**
+   * 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.
+   *
+   * @returns The current context ID.
+   */
+  getCurrentContextId() {
+    return this.currentContextId;
+  }
+  /**
+   * Sets the current context booth ID.
+   * Throws an error if the provided ID is not registered.
+   *
+   * @param contextId - The booth ID to set as current context.
+   */
+  setCurrentContextId(t) {
+    if (!this.booths[t])
+      throw new Error(`Booth with ID ${t} is not registered.`);
+    this.currentContextId = t;
+  }
+  /**
+   * Returns the current context booth configuration.
+   * Throws an error if the current context booth is not registered.
+   *
+   * @returns The current context booth configuration.
+   */
+  get currentContextBoothConfig() {
+    const t = this.getBoothById(this.currentContextId);
+    if (!t)
+      throw new Error(`Booth with ID ${this.currentContextId} is not registered.`);
+    return t;
+  }
+  /**
+   * Registers a single booth configuration in the registry.
+   * Throws an error if a booth with the same ID already exists.
+   *
+   * @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;
+  }
+  /**
+   * Returns the base booth configuration that was provided during initialization.
+   * This configuration serves as the foundation for all booth interactions.
+   *
+   * @returns The base booth configuration
+   */
+  get baseBoothConfig() {
+    return this.baseBooth;
+  }
+  /**
+   * Returns the orchestrator booth configuration.
+   * The orchestrator booth is responsible for managing booth routing and coordination.
+   * Throws an error if the orchestrator booth is not registered.
+   *
+   * @returns The orchestrator booth configuration
+   */
+  get orchestratorBoothConfig() {
+    const t = this.getBoothById("orchestrator");
+    if (!t)
+      throw new Error("Base booth does not have an orchestrator configuration.");
+    return t;
+  }
+  /**
+   * Registers multiple booth configurations at once.
+   *
+   * @param boothConfigs - Array of booth configurations to register
+   */
+  registerBooths(t) {
+    for (const o of t)
+      this.registerBooth(o);
+  }
+  /**
+   * Finds and returns a booth configuration by its ID.
+   *
+   * @param boothId - The unique identifier of the booth to retrieve
+   * @returns The booth configuration if found, undefined otherwise
+   */
+  getBoothById(t) {
+    return this.booths[t];
+  }
+  /**
+   * Returns all registered booth configurations.
+   *
+   * @returns Record of all booth configurations indexed by their IDs
+   */
+  getAllBooths() {
+    return this.booths;
+  }
+  /**
+   * Removes a booth configuration from the registry by its ID.
+   * Throws an error if the booth doesn't exist.
+   *
+   * @param boothId - The unique identifier of the booth to remove
+   */
+  unregisterBooth(t) {
+    if (!this.booths[t])
+      throw new Error(`Booth with ID ${t} does not exist.`);
+    delete this.booths[t];
+  }
+}
+class d {
+  /**
+   * 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.
+   */
+  constructor(t, o, e, r) {
+    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
+   * @param responseCreateParams - The original request parameters
+   * @returns A properly structured Response object representing the error
+   * @private
+   */
+  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", n = {
+      code: "server_error",
+      message: e
+    };
+    if (r && (n.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: n,
+      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"
+    };
+  }
+  /**
+   * Calls the LLM with the given parameters.
+   * @param responseCreateParams - The parameters for creating the response.
+   * @returns A promise that resolves with the LLM's response.
+   * @private
+   */
+  async callLLM(t) {
+    try {
+      const o = await this.llmAdapter.invoke(t);
+      return await this.llmAdapter.interpret(o);
+    } catch (o) {
+      return console.error("Error calling LLM:", o), this.createErrorResponse(o, t);
+    }
+  }
+  /**
+   * Runs the main interaction loop, sending messages to the LLM and processing
+   * the responses through the registered plugins.
+   * @param initialResponseParams - The initial parameters for the response.
+   * @returns A promise that resolves with the final response from the LLM.
+   * @private
+   */
+  async runInteractionLoop(t) {
+    let o = 0, e = t, r, n = !0;
+    for (; n && o < this.loopLimit; )
+      o++, e = await this.boothPlugins.runBeforeMessageSend(
+        {
+          toolRegistry: this.toolRegistry,
+          boothRegistry: this.boothRegistry,
+          pluginRegistry: this.boothPlugins
+        },
+        e
+      ), r = await this.callLLM(e), e = await this.boothPlugins.runResponseReceived(
+        {
+          toolRegistry: this.toolRegistry,
+          boothRegistry: this.boothRegistry,
+          pluginRegistry: this.boothPlugins
+        },
+        e,
+        r
+      ), await this.boothPlugins.runShouldEndInteractionLoop(
+        {
+          toolRegistry: this.toolRegistry,
+          boothRegistry: this.boothRegistry,
+          pluginRegistry: this.boothPlugins
+        },
+        e,
+        r
+      ) && (n = !1);
+    if (!r)
+      throw new Error("No response received from LLM");
+    return r;
+  }
+  /**
+   * Sends a message to the LLM and processes the response through the interaction loop.
+   * This involves running pre-loop, pre-send, response-received, and post-loop plugin hooks.
+   * @param input The input message to send.
+   * @returns The processed response from the LLM.
+   */
+  async send(t) {
+    let o = {
+      input: [
+        {
+          role: "user",
+          content: t
+        }
+      ],
+      tools: []
+    };
+    o = await this.boothPlugins.runBeforeInteractionLoopStart(
+      {
+        toolRegistry: this.toolRegistry,
+        boothRegistry: this.boothRegistry,
+        pluginRegistry: this.boothPlugins
+      },
+      o,
+      t
+    );
+    let e = await this.runInteractionLoop(o);
+    return e = await this.boothPlugins.runAfterInteractionLoopEnd(
+      {
+        toolRegistry: this.toolRegistry,
+        boothRegistry: this.boothRegistry,
+        pluginRegistry: this.boothPlugins
+      },
+      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.";
+  /**
+   * Returns the plugin's unique identifier.
+   */
+  get id() {
+    return this.plugin_id;
+  }
+  /**
+   * Returns the plugin's display name.
+   */
+  get name() {
+    return this.plugin_name;
+  }
+  /**
+   * Returns the plugin's description.
+   */
+  get description() {
+    return this.plugin_description;
+  }
+  /**
+   * Executes before the interaction loop starts, adding the current user input to the
+   * conversation history and updating the response parameters with the complete history.
+   *
+   * @param _ - Object containing the booth registry and context booth ID (unused in this method)
+   * @param responseParams - Current parameters for the LLM response creation
+   * @returns Updated response parameters with the complete conversation history
+   */
+  async onBeforeInteractionLoopStart(t, o) {
+    const { input: e } = o, r = typeof e == "string" ? [{ role: "user", content: e }] : e || [];
+    return a.push(...r), {
+      ...o,
+      input: a
+    };
+  }
+  /**
+   * Executes after receiving a response from the LLM, adding the response content
+   * to the conversation history for future reference.
+   *
+   * @param _
+   * @param responseParams - Current parameters for the LLM response creation
+   * @param response
+   * @returns Unmodified response parameters
+   */
+  async onResponseReceived(t, o, e) {
+    const n = [...o.input, ...e.output];
+    return a = n, {
+      ...o,
+      input: n
+    };
+  }
+  /**
+   * Determines whether the interaction loop should end.
+   * This implementation always returns false, indicating the loop should continue.
+   *
+   * @returns A promise resolving to false, indicating the interaction should continue
+   */
+  async shouldEndInteractionLoop() {
+    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.";
+  /**
+   * Returns the plugin's unique identifier.
+   */
+  get id() {
+    return this.plugin_id;
+  }
+  /**
+   * Returns the plugin's display name.
+   */
+  get name() {
+    return this.plugin_name;
+  }
+  /**
+   * Returns the plugin's description.
+   */
+  get description() {
+    return this.plugin_description;
+  }
+  /**
+   * Executes before the interaction loop starts, adding context from both the base booth
+   * and the current context booth to the response parameters.
+   *
+   * @param prepareInitialMessagesArgs - Object containing the booth registry and current context booth ID
+   * @param responseParams - Current parameters for the LLM response creation
+   * @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 += `
+
+ ${r.description}`, { ...o, instructions: n };
+  }
+  /**
+   * Determines whether the interaction loop should end.
+   * This implementation always returns false, indicating the loop should continue.
+   *
+   * @returns A promise resolving to false, indicating the interaction should continue
+   */
+  async shouldEndInteractionLoop() {
+    return !1;
+  }
+}
+class m {
+  tools;
+  /**
+   * Initializes an empty Map to store tools.
+   */
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  registerTools(t) {
+    t.forEach((o) => this.registerTool(o));
+  }
+  /**
+   * Registers a single tool in the registry.
+   * Throws an error if a tool with the same ID already exists.
+   *
+   * @param tool - The OpenAI Tool instance to register
+   * @throws Error if a tool with the same ID is already registered
+   */
+  registerTool(t) {
+    if (this.tools.has(t.name))
+      throw new Error(`Tool with ID ${t.name} is already registered.`);
+    this.tools.set(t.name, t);
+  }
+  /**
+   * Finds and returns a tool by its ID.
+   *
+   * @param toolName - The unique identifier of the tool to retrieve
+   * @returns The tool instance if found, undefined otherwise
+   */
+  getTool(t) {
+    const o = this.tools.get(t);
+    if (!o)
+      throw new Error(`Tool with name ${t} is not registered.`);
+    return o;
+  }
+  /**
+   * Returns all registered tools as an array.
+   *
+   * @returns Array of all registered Tool instances
+   */
+  getAllTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Removes a tool from the registry by its ID.
+   * Throws an error if the tool doesn't exist.
+   *
+   * @param toolName - The unique identifier of the tool to remove
+   * @throws Error if the tool with the specified ID does not exist
+   */
+  unregisterTool(t) {
+    if (!this.tools.has(t))
+      throw new Error(`Tool with ID ${t} is not registered.`);
+    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";
+  /**
+   * 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
+   * response parameters. It also checks for duplicate tool keys.
+   * @param prepareInitialMessagesArgs - Utilities for accessing booth and tool registries.
+   * @param responseParams - The parameters for the response creation.
+   * @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();
+    for (const u of n) {
+      if (s.has(u))
+        throw new Error(`Duplicate tool key detected: ${u}`);
+      s.add(u);
+    }
+    const l = n.map(
+      (u) => t.toolRegistry.getTool(u)
+    );
+    return e.mcp && l.push(...e.mcp), r?.mcp && l.push(...r.mcp), {
+      ...o,
+      tools: l
+    };
+  }
+  /**
+   * Determines whether the interaction loop should end. This plugin always returns false,
+   * as providing tools is part of setting up the interaction, not concluding it.
+   * @returns A boolean indicating that the loop should not end.
+   */
+  async shouldEndInteractionLoop() {
+    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.";
+  /**
+   * 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.
+   * @private
+   */
+  async executeToolCall(t, o, e) {
+    try {
+      const r = await t.pluginRegistry.runBeforeToolCall(
+        t,
+        o,
+        e
+      ), n = t.toolRegistry.getTool(r.name);
+      if (!n)
+        return {
+          type: "function_call_output",
+          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(
+        t,
+        r,
+        s,
+        e
+      );
+      return {
+        type: "function_call_output",
+        call_id: r.call_id,
+        output: JSON.stringify(l)
+      };
+    } catch (r) {
+      console.error(`Error executing tool ${o.name}:`, r);
+      const n = await t.pluginRegistry.runToolCallError(
+        t,
+        o,
+        r,
+        e
+      );
+      return {
+        type: "function_call_output",
+        call_id: o.call_id,
+        output: typeof n == "string" ? n : JSON.stringify(n)
+      };
+    }
+  }
+  /**
+   * After a response is received from the LLM, this hook checks for tool calls. If any are found,
+   * it executes them using the `toolRegistry` and appends their outputs to the response parameters'
+   * input history.
+   * @param utilities - The repository utilities containing available tools.
+   * @param responseParams - The parameters for the response creation.
+   * @param response - The response from the LLM.
+   * @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"
+    );
+    if (!n.length)
+      return o;
+    const s = [];
+    for (let l = 0; l < n.length; l++) {
+      const u = n[l], c = {
+        responseParams: o,
+        response: e,
+        toolCallIndex: l,
+        totalToolCalls: n.length
+      }, h = await this.executeToolCall(t, u, c);
+      s.push(h);
+    }
+    return {
+      ...o,
+      input: [...o.input, ...s]
+    };
+  }
+  /**
+   * Determines whether the interaction loop should end. This plugin always returns false,
+   * as tool execution is part of an ongoing conversation.
+   * @returns A boolean indicating that the loop should not end.
+   */
+  async shouldEndInteractionLoop() {
+    return !1;
+  }
+}
+function R(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 _ {
+  description = "A plugin to ensure the interaction loop can be finished.";
+  id = "finish-turn-plugin";
+  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.
+   * @param _ - Unused repository utilities.
+   * @param responseParams - The parameters for the response creation.
+   * @returns The updated response parameters with the added instruction.
+   */
+  async onBeforeMessageSend(t, o) {
+    let e = o.instructions || "";
+    return e += `
+    
+
+ Once a user response is expected, at the end of your message, add "__awaiting_user_response__" to your message.`, {
+      ...o,
+      instructions: e
+    };
+  }
+  /**
+   * Determines whether the interaction loop should end by checking for the presence of the
+   * `__awaiting_user_response__` marker in the response text or if there's an error response.
+   * @param _ - Unused repository utilities.
+   * @param __ - Unused response parameters.
+   * @param response - The response from the LLM.
+   * @returns A boolean indicating whether the loop should end.
+   */
+  async shouldEndInteractionLoop(t, o, e) {
+    const r = e.output_text.includes("__awaiting_user_response__"), n = e.status === "failed" || e.error !== null;
+    return r || n;
+  }
+  /**
+   * After the interaction loop ends, this hook removes the `__awaiting_user_response__` marker
+   * from the final response before it is returned.
+   * @param _ - Unused repository utilities.
+   * @param response - The final response from the LLM.
+   * @returns The cleaned response.
+   */
+  async onAfterInteractionLoopEnd(t, o) {
+    const e = JSON.stringify(o);
+    if (e.includes("__awaiting_user_response__")) {
+      const r = e.replace(/__awaiting_user_response__/g, "");
+      return JSON.parse(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;
+  /**
+   * Initializes a new instance of the CoreBooth class.
+   * Sets up the plugin registries, system plugins, and interaction processor.
+   *
+   * @param {Object} options - Configuration options for the CoreBooth
+   * @param {BoothPluginRegistry} options.boothPlugins - Registry containing user-defined plugins
+   * @param {BoothRegistry} options.booths - Registry containing booth configurations
+   * @param {ToolRegistry} options.tools - Registry containing tool configurations
+   */
+  constructor(t) {
+    this.boothPluginRegistry = t.boothPlugins, this.boothRegistry = t.booths, this.toolRegistry = t.tools;
+    const o = R(this.boothRegistry);
+    this.toolRegistry.registerTools([o]), this.systemPluginsRegistry = new g(), this.systemPluginsRegistry.registerPlugins([
+      new p(),
+      new f(),
+      new y(),
+      new w(),
+      new _()
+    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new d(
+      this.boothRegistry,
+      this.systemPluginsRegistry,
+      this.toolRegistry,
+      t.llmAdapter
+    );
+  }
+}
+export {
+  g as BoothPluginRegistry,
+  b as BoothRegistry,
+  f as ContextProviderPlugin,
+  p as ConversationHistoryPlugin,
+  B as CoreBooth,
+  _ as FinishTurnPlugin,
+  d as InteractionProcessor,
+  w as ToolExecutorPlugin,
+  y as ToolProviderPlugin,
+  m as ToolRegistry,
+  R as createRouteToBoothTool
+};