booths 0.1.3 → 1.1.0

package/dist/index.js

@@ -1,14 +1,9 @@
-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", []);
-  }
+class p {
+  /**
+   * 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.
@@ -70,8 +65,8 @@ class R {
    */
   async runBeforeInteractionLoopStart(t, o, e) {
     let r = o;
-    for (const n of this.plugins)
-      n.onBeforeInteractionLoopStart && (r = await n.onBeforeInteractionLoopStart(t, r, e));
+    for (const s of this.plugins)
+      s.onBeforeInteractionLoopStart && (r = await s.onBeforeInteractionLoopStart(t, r, e));
     return r;
   }
   /**
@@ -101,8 +96,8 @@ class R {
    */
   async runResponseReceived(t, o, e) {
     let r = o;
-    for (const n of this.plugins)
-      n.onResponseReceived && (r = await n.onResponseReceived(t, r, e));
+    for (const s of this.plugins)
+      s.onResponseReceived && (r = await s.onResponseReceived(t, r, e));
     return r;
   }
   /**
@@ -150,8 +145,8 @@ class R {
    */
   async runBeforeToolCall(t, o, e) {
     let r = o;
-    for (const n of this.plugins)
-      n.onBeforeToolCall && (r = await n.onBeforeToolCall(t, r, e));
+    for (const s of this.plugins)
+      s.onBeforeToolCall && (r = await s.onBeforeToolCall(t, r, e));
     return r;
   }
   /**
@@ -166,10 +161,10 @@ class R {
    * @returns Modified result after all plugins have processed it
    */
   async runAfterToolCall(t, o, e, r) {
-    let n = e;
-    for (const a of this.plugins)
-      a.onAfterToolCall && (n = await a.onAfterToolCall(t, o, n, r));
-    return n;
+    let s = e;
+    for (const l of this.plugins)
+      l.onAfterToolCall && (s = await l.onAfterToolCall(t, o, s, r));
+    return s;
   }
   /**
    * Sequentially invokes every plugin's onToolCallError hook.
@@ -183,13 +178,48 @@ class R {
    * @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 a of this.plugins)
-      a.onToolCallError && (n = await a.onToolCallError(t, o, e, r));
-    return n;
+    let s = `Error: ${e.message}`;
+    for (const l of this.plugins)
+      l.onToolCallError && (s = await l.onToolCallError(t, o, e, r));
+    return s;
   }
 }
-class T {
+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 R {
   /**
    * Creates a new booth registry with a specified base booth configuration.
    *
@@ -197,18 +227,35 @@ class T {
    * @param currentContextId - The initial current context booth ID (default is 'orchestrator')
    */
   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;
+  /**
+   * Tracks whether the orchestrator booth is currently registered.
+   * @private
+   */
+  hasOrchestrator = !1;
+  /**
+   * Optional callback function that gets called when multi-booth mode is enabled.
+   * Used to coordinate external actions like tool registration.
+   * @private
+   */
+  onMultiBoothModeEnabled;
+  /**
+   * Optional callback function that gets called when multi-booth mode is disabled.
+   * Used to coordinate external actions like tool unregistration.
+   * @private
+   */
+  onMultiBoothModeDisabled;
   /**
    * Gets the current context booth ID.
    *
@@ -247,7 +294,11 @@ class T {
    * @param boothConfig - The booth configuration to register
    */
   registerBooth(t) {
-    this.booths[t.id] || (this.booths[t.id] = 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();
   }
   /**
    * Returns the base booth configuration that was provided during initialization.
@@ -297,12 +348,37 @@ class T {
   getAllBooths() {
     return this.booths;
   }
+  toArray() {
+    return Object.values(this.booths);
+  }
+  /**
+   * Enables multi-booth mode by registering the orchestrator and setting it as current context.
+   * @private
+   */
+  enableMultiBoothMode() {
+    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[u.id], this.hasOrchestrator = !1, this.currentContextId = this.baseBooth.id, this.onMultiBoothModeDisabled?.());
+  }
   /**
-   * Checks if the registry is operating in a multi-booth configuration.
-   * @returns {boolean} `true` if there is more than one booth registered, otherwise `false`.
+   * Sets callback functions for when multi-booth mode is enabled/disabled.
+   * Used to coordinate external actions like tool registration/unregistration.
+   *
+   * @param onEnabled - Callback for when multi-booth mode is enabled
+   * @param onDisabled - Callback for when multi-booth mode is disabled
    */
+  setMultiBoothModeCallbacks(t, o) {
+    this.onMultiBoothModeEnabled = t, this.onMultiBoothModeDisabled = o;
+  }
   get isMultiBoothMode() {
-    return Object.keys(this.booths).length > 1;
+    return Object.keys(this.booths).filter(
+      (o) => o !== u.id
+    ).length > 1;
   }
   /**
    * Removes a booth configuration from the registry by its ID.
@@ -313,10 +389,16 @@ class T {
   unregisterBooth(t) {
     if (!this.booths[t])
       throw new Error(`Booth with ID ${t} does not exist.`);
-    delete this.booths[t];
+    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 E {
+class B {
   /**
    * Creates an instance of InteractionProcessor.
    * @param boothRegistry - The registry for booth configurations.
@@ -325,9 +407,9 @@ class E {
    * @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
@@ -336,17 +418,17 @@ class E {
    * @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 = {
+    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 && (n.code = r), o.model === void 0)
+    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: n,
+      error: s,
       incomplete_details: null,
       instructions: null,
       metadata: null,
@@ -397,8 +479,8 @@ class E {
    * @private
    */
   async runInteractionLoop(t) {
-    let o = 0, e = t, r, n = !0;
-    for (; n && o < this.loopLimit; )
+    let o = 0, e = t, r, s = !0;
+    for (; s && o < this.loopLimit; )
       o++, e = await this.boothPlugins.runBeforeMessageSend(
         {
           toolRegistry: this.toolRegistry,
@@ -425,7 +507,7 @@ class E {
         },
         e,
         r
-      ) && (n = !1);
+      ) && (s = !1);
     if (!r)
       throw new Error("No response received from LLM");
     return r;
@@ -437,53 +519,55 @@ class E {
    * @returns The processed response from the LLM.
    */
   async send(t) {
-    let o = {
-      input: [
-        {
-          role: "user",
-          content: t
-        }
-      ],
+    let o;
+    typeof t == "string" ? o = [
+      {
+        role: "user",
+        content: t
+      }
+    ] : o = t;
+    let e = {
+      input: o,
       tools: []
     };
-    o = await this.boothPlugins.runBeforeInteractionLoopStart(
+    e = await this.boothPlugins.runBeforeInteractionLoopStart(
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
         pluginRegistry: this.boothPlugins,
         llmAdapter: this.llmAdapter
       },
-      o,
+      e,
       t
     );
-    let e = await this.runInteractionLoop(o);
-    return e = await this.boothPlugins.runAfterInteractionLoopEnd(
+    let r = await this.runInteractionLoop(e);
+    return r = await this.boothPlugins.runAfterInteractionLoopEnd(
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
         pluginRegistry: this.boothPlugins,
         llmAdapter: this.llmAdapter
       },
-      e
-    ), e;
+      r
+    ), r;
   }
 }
-const C = {
+const T = {
   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(
+}, f = "route_to_booth";
+function y(n) {
+  const t = n.getAllBooths(), o = Object.values(t).map(
     (r) => `- ${r.id}: ${r.role}
   Examples:
-${(r.examples || []).map((n) => `    - "${n}"`).join(`
+${(r.examples || []).map((s) => `    - "${s}"`).join(`
 `)}`
   ).join(`
 `), e = Object.keys(t);
   return {
     type: "function",
-    name: d,
+    name: f,
     description: `
     Routes the conversation to a specialized booth based on the user's needs. Each booth has a 
     specific role and set of capabilities.
@@ -513,41 +597,68 @@ ${o}
      */
     execute: async function({ targetBooth: r }) {
       try {
-        return i.setCurrentContextId(r), {
+        return n.setCurrentContextId(r), {
           content: `Routed to booth ${r}`
         };
-      } catch (n) {
-        return console.error("[routeToBoothTool] Error routing to booth:", n), {
+      } catch (s) {
+        return console.error("[routeToBoothTool] Error routing to booth:", s), {
           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.");
-  }
+class v {
+  /**
+   * The sessionHistory variable stores the conversation history between the user and the booth system.
+   * It is initialized as an empty array and will be populated with messages exchanged during the interaction.
+   */
+  sessionHistory = [];
+  /**
+   * 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.";
+  /**
+   * Checks if the given response contains a booth change.
+   *
+   * A booth change is determined by examining the response's output for a specific tool call to 'route_to_booth'.
+   * The output can either include a direct function call object or a message containing a list of tool calls.
+   *
+   * @param response - The response objects to be checked. It is expected to contain an `output` property.
+   * @return A boolean indicating whether a booth change is present in the response.
+   */
   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
+    return t.output ? t.output.some((o) => o.type === "function_call" ? o.name === f : o.type === "message" && "tool_calls" in o && Array.isArray(o.tool_calls) ? o.tool_calls.some(
+      (e) => e.type === "function" && e.function.name === f
     ) : !1) : !1;
   }
+  /**
+   * Constructs a new instance with an optional session history.
+   *
+   * @param {ResponseInput[]} [sessionHistory=[]] - An array representing the session history. Defaults to an empty array if not provided.
+   */
+  constructor(t = []) {
+    this.sessionHistory = t;
+  }
+  /**
+   * Retrieves the session history.
+   *
+   * @return {Array} The history of the current session.
+   */
+  get history() {
+    return this.sessionHistory;
+  }
   /**
    * Returns the plugin's unique identifier.
    */
@@ -576,37 +687,35 @@ class I {
    */
   async onBeforeInteractionLoopStart(t, o) {
     const { input: e } = o, r = typeof e == "string" ? [{ role: "user", content: e }] : e || [];
-    return c.push(...r), {
+    return this.sessionHistory.push(...r), {
       ...o,
-      input: c
+      input: this.sessionHistory
     };
   }
   /**
    * Executes after receiving a response from the LLM, adding the response content
    * to the conversation history for future reference.
    *
-   * @param _
+   * @param utilities
    * @param responseParams - Current parameters for the LLM response creation
    * @param response
    * @returns Unmodified response parameters
    */
   async onResponseReceived(t, o, e) {
-    let n = [...o.input, ...(e == null ? void 0 : e.output) ?? []];
+    let s = [...o.input, ...e?.output ?? []];
     if (this.responseContainsBoothChange(e)) {
-      const l = `Please summarize the following conversation history:
+      const i = `Please summarize the following conversation history:
 
-${JSON.stringify(c)}`, g = (await S(t.llmAdapter, C).callProcessor.send(l)).output_text, y = n.filter((h) => "role" in h && h.role === "user").pop(), f = {
+${JSON.stringify(this.sessionHistory)}`, d = (await A(t.llmAdapter, T).callProcessor.send(i)).output_text, g = s.filter((h) => "role" in h && h.role === "user").pop(), b = {
         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 = y ? [...m, f, y] : [...m, f], n = c;
+        content: `A conversation summary up to this point: ${d}`
+      }, _ = s.filter((h) => !("role" in h && h.role === "user" || "type" in h && h.type === "message"));
+      this.sessionHistory = g ? [..._, b, g] : [..._, b], s = this.sessionHistory;
     } else
-      c = n;
+      this.sessionHistory = s;
     return {
       ...o,
-      input: n
+      input: s
     };
   }
   /**
@@ -619,24 +728,22 @@ ${JSON.stringify(c)}`, g = (await S(t.llmAdapter, C).callProcessor.send(l)).outp
     return !1;
   }
 }
-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.");
-  }
+class E {
+  /**
+   * 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.
    */
@@ -665,16 +772,16 @@ class v {
    */
   async onBeforeMessageSend(t, o) {
     const e = t.boothRegistry;
-    let n = e.baseBoothConfig.description;
+    let s = e.baseBoothConfig.description;
     if (e.isMultiBoothMode) {
-      const a = e.orchestratorBoothConfig, l = e.currentContextBoothConfig;
-      n += `
+      const l = e.orchestratorBoothConfig, i = e.currentContextBoothConfig;
+      s += `
 
- ${a.description}`, l.id !== a.id && (n += `
+ ${l.description}`, i.id !== l.id && (s += `
 
- ${l.description}`);
+ ${i.description}`);
     }
-    return { ...o, instructions: n };
+    return { ...o, instructions: s };
   }
   /**
    * Determines whether the interaction loop should end.
@@ -686,12 +793,12 @@ class v {
     return !1;
   }
 }
-class A {
+class w {
+  tools;
   /**
    * Initializes an empty Map to store tools.
    */
   constructor() {
-    s(this, "tools");
     this.tools = /* @__PURE__ */ new Map();
   }
   registerTools(t) {
@@ -705,7 +812,9 @@ class A {
    */
   registerTool(t) {
     if (this.tools.has(t.name)) {
-      console.warn(`Tool with ID '${t.name}' is already registered. Duplicate registration ignored.`);
+      console.warn(
+        `Tool with ID '${t.name}' is already registered. Duplicate registration ignored.`
+      );
       return;
     }
     this.tools.set(t.name, t);
@@ -722,13 +831,34 @@ class A {
       throw new Error(`Tool with name ${t} is not registered.`);
     return o;
   }
+  getGlobalTools() {
+    return Array.from(this.tools.values()).filter((t) => t.global);
+  }
   /**
    * Returns all registered tools as an array.
    *
    * @returns Array of all registered Tool instances
    */
-  getAllTools() {
-    return Array.from(this.tools.values());
+  getServerTools() {
+    return Array.from(this.tools.values()).filter((t) => t.execute !== void 0);
+  }
+  /**
+   * Returns local tools. Local tools are distinguished by not having the execute method.
+   */
+  getLocalTools() {
+    return Array.from(this.tools.values()).filter((t) => t.execute === void 0);
+  }
+  /**
+   * Determines if the specified tool is a local tool.
+   *
+   * A local tool is identified by the `execute` property being undefined.
+   *
+   * @param {string} toolName - The name of the tool to be checked.
+   * @return {boolean} - Returns true if the specified tool is a local tool, false otherwise.
+   */
+  isLocalTool(t) {
+    const o = this.tools.get(t);
+    return o ? o.execute === void 0 : !1;
   }
   /**
    * Removes a tool from the registry by its ID.
@@ -743,12 +873,41 @@ class A {
     this.tools.delete(t);
   }
 }
-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");
+function C(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 I(n) {
+  const t = /* @__PURE__ */ new Set(), o = [];
+  for (const e of n) {
+    const r = C(e);
+    t.has(r) || (t.add(r), o.push(e));
+  }
+  return o;
+}
+class x {
+  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
@@ -758,16 +917,18 @@ class P {
    * @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 == null ? void 0 : r.tools) || []], l = [...new Set(n)].map(
-      (u) => t.toolRegistry.getTool(u)
+    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, i = [...e.tools || [], ...r?.tools || []].filter((a, d, g) => g.indexOf(a) === d).map(
+      (a) => t.toolRegistry.getTool(a)
     );
-    if (e.mcp && l.push(...e.mcp), r != null && r.mcp && l.push(...r.mcp), t.boothRegistry.isMultiBoothMode) {
-      const u = w(t.boothRegistry);
-      l.push(u);
+    if (e.mcp && i.push(...e.mcp), r?.mcp && i.push(...r.mcp), t.boothRegistry.isMultiBoothMode) {
+      const a = y(t.boothRegistry);
+      i.push(a);
     }
+    i.push(...t.toolRegistry.getGlobalTools());
+    const c = I(i);
     return {
       ...o,
-      tools: l
+      tools: c
     };
   }
   /**
@@ -779,12 +940,10 @@ class P {
     return !1;
   }
 }
-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.");
-  }
+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.";
   /**
    * Executes a single tool call with proper hook integration.
    * @param utilities - Repository utilities for accessing registries.
@@ -799,27 +958,33 @@ class x {
         t,
         o,
         e
-      ), n = t.toolRegistry.getTool(r.name);
-      if (!n)
+      ), 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.`
         };
-      const a = await n.execute(JSON.parse(r.arguments)), l = await t.pluginRegistry.runAfterToolCall(
+      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 l = await s.execute(JSON.parse(r.arguments)), i = await t.pluginRegistry.runAfterToolCall(
         t,
         r,
-        a,
+        l,
         e
       );
       return {
         type: "function_call_output",
         call_id: r.call_id,
-        output: JSON.stringify(l)
+        output: JSON.stringify(i)
       };
     } catch (r) {
       console.error(`Error executing tool ${o.name}:`, r);
-      const n = await t.pluginRegistry.runToolCallError(
+      const s = await t.pluginRegistry.runToolCallError(
         t,
         o,
         r,
@@ -828,10 +993,15 @@ class x {
       return {
         type: "function_call_output",
         call_id: o.call_id,
-        output: typeof n == "string" ? n : JSON.stringify(n)
+        output: typeof s == "string" ? s : JSON.stringify(s)
       };
     }
   }
+  static extractFunctionCalls(t) {
+    return t.filter(
+      (o) => o.type === "function_call"
+    );
+  }
   /**
    * 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'
@@ -842,24 +1012,25 @@ class x {
    * @returns The updated response parameters, potentially with tool call outputs added to the input.
    */
   async onResponseReceived(t, o, e) {
-    const r = (e == null ? void 0 : e.output) ?? [], n = (r == null ? void 0 : r.filter(
-      (l) => l.type === "function_call"
-    )) ?? [];
-    if (!n.length)
+    const r = e?.output ?? [], s = m.extractFunctionCalls(r);
+    if (!s.length)
       return o;
-    const a = [];
-    for (let l = 0; l < n.length; l++) {
-      const u = n[l], p = {
+    const l = [];
+    for (let i = 0; i < s.length; i++) {
+      const c = s[i];
+      if (t.toolRegistry.isLocalTool(c.name))
+        continue;
+      const a = {
         responseParams: o,
         response: e,
-        toolCallIndex: l,
-        totalToolCalls: n.length
-      }, g = await this.executeToolCall(t, u, p);
-      a.push(g);
+        toolCallIndex: i,
+        totalToolCalls: s.length
+      }, d = await this.executeToolCall(t, c, a);
+      l.push(d);
     }
     return {
       ...o,
-      input: [...o.input, ...a]
+      input: [...o.input, ...l]
     };
   }
   /**
@@ -871,12 +1042,10 @@ class x {
     return !1;
   }
 }
-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");
-  }
+class M {
+  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.
@@ -911,8 +1080,8 @@ class L {
   async shouldEndInteractionLoop(t, o, e) {
     if (!e.output_text)
       return !1;
-    const r = e.output_text.includes("__awaiting_user_response__"), n = e.status === "failed" || e.error !== null;
-    return r || n;
+    const r = e.output_text.includes("__awaiting_user_response__"), s = e.status === "failed" || e.error !== null;
+    return r || s;
   }
   /**
    * After the interaction loop ends, this hook removes the `__awaiting_user_response__` marker
@@ -930,51 +1099,60 @@ class L {
     return o;
   }
 }
-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,
+function A(n, t) {
+  const o = new R(t), e = new w(), r = new p();
+  return new P({
+    llmAdapter: n,
     booths: o,
     tools: e,
     boothPlugins: r
   });
 }
-class M {
+class P {
+  /**
+   * 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.
@@ -985,62 +1163,24 @@ class M {
    * @param {ToolRegistry} options.tools - Registry containing tool configurations
    */
   constructor(t) {
-    /**
-     * 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);
+    if (this.boothPluginRegistry = t?.boothPlugins ?? new p(), this.boothRegistry = t.booths, this.toolRegistry = t?.tools ?? new w(), 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 R(), this.systemPluginsRegistry.registerPlugins([
-      new I(),
-      new v(),
-      new P(),
+    this.systemPluginsRegistry = new p(), this.systemPluginsRegistry.registerPlugins([
+      new v(t.sessionHistory),
+      new E(),
       new x(),
-      new L()
-    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new E(
+      new m(),
+      new M()
+    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new B(
       this.boothRegistry,
       this.systemPluginsRegistry,
       this.toolRegistry,
@@ -1049,16 +1189,16 @@ class M {
   }
 }
 export {
-  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
+  p as BoothPluginRegistry,
+  R as BoothRegistry,
+  E as ContextProviderPlugin,
+  v as ConversationHistoryPlugin,
+  P as CoreBooth,
+  M as FinishTurnPlugin,
+  B as InteractionProcessor,
+  m as ToolExecutorPlugin,
+  x as ToolProviderPlugin,
+  w as ToolRegistry,
+  A as createCoreBooth,
+  y as createRouteToBoothTool
 };