booths 1.3.1 → 1.4.1

package/dist/index.js

@@ -1,5 +1,4 @@
-import { randomUUID as R } from "crypto";
-class p {
+class y {
   /**
    * Collection of registered plugins.
    * @private
@@ -135,7 +134,7 @@ class p {
         o,
         e
       ))
-        return !0;
+        return console.log(`BoothPluginRegistry: Plugin ${r.id} indicated loop should end.`), !0;
     return !1;
   }
   /**
@@ -202,28 +201,6 @@ class p {
       i.onToolCallError && (s = await i.onToolCallError(t, o, e, r));
     return s;
   }
-  /**
-   * Sequentially invokes every plugin's onStreamEvent hook.
-   * This is called for each streaming event during response generation,
-   * allowing plugins to process or modify stream events in real-time.
-   * 
-   * @param utilities - Context information including booth and tool registries
-   * @param streamEvent - The streaming event that was received
-   * @param context - Context information about the streaming session
-   * @returns Modified stream event after all plugins have processed it
-   */
-  async runStreamEvent(t, o, e) {
-    let r = o;
-    for (const s of this.plugins)
-      if (s.onStreamEvent)
-        try {
-          const i = await s.onStreamEvent(t, r, e);
-          i && (r = i);
-        } catch (i) {
-          console.error(`Error in plugin ${s.id} during stream event processing:`, i);
-        }
-    return r;
-  }
 }
 const u = {
   id: "orchestrator",
@@ -260,7 +237,7 @@ const u = {
     - User: "I need help" → "What specifically would you like help with?" → then route based on response
   `
 };
-class B {
+class T {
   /**
    * Creates a new booth registry with a specified base booth configuration.
    *
@@ -407,6 +384,18 @@ class B {
   getAllBooths() {
     return this.booths;
   }
+  /**
+   * Returns only booths that should be available for routing (excludes core and orchestrator booths).
+   * This prevents double context issues by ensuring system booths are not selectable.
+   *
+   * @returns Record of selectable booth configurations indexed by their IDs
+   */
+  getSelectableBooths() {
+    const t = {};
+    for (const [o, e] of Object.entries(this.booths))
+      o !== this.baseBooth.id && o !== u.id && (t[o] = e);
+    return t;
+  }
   toArray() {
     return Object.values(this.booths);
   }
@@ -457,54 +446,18 @@ class B {
     ).length <= 1 && this.hasOrchestrator && this.disableMultiBoothMode();
   }
 }
-class T {
+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 llmAdapter - The adapter for interacting with the LLM.
-   * @param options - Configuration options for streaming and other behaviors.
-   */
-  constructor(t, o, e, r, s) {
-    this.boothRegistry = t, this.boothPlugins = o, this.toolRegistry = e, this.llmAdapter = r, this.options = {
-      streaming: !1,
-      fallbackToNonStreaming: !0,
-      ...s
-    };
-  }
-  /**
-   * Generates a consistent ID for responses and messages.
-   * @param prefix - The prefix for the ID (e.g., 'stream', 'error', 'msg')
-   * @returns A unique ID string
-   * @private
-   */
-  generateId(t) {
-    return `${t}_${Date.now()}_${R()}`;
-  }
-  /**
-   * Creates a standardized message object for responses.
-   * @param text - The text content for the message
-   * @returns A formatted message object
-   * @private
    */
-  createMessage(t) {
-    return {
-      id: this.generateId("msg"),
-      content: [
-        {
-          type: "output_text",
-          text: t,
-          annotations: []
-        }
-      ],
-      role: "assistant",
-      status: "completed",
-      type: "message"
-    };
+  constructor(t, o, e, r) {
+    this.boothRegistry = t, this.boothPlugins = o, this.toolRegistry = e, this.llmAdapter = r;
   }
   loopLimit = 10;
-  options;
   /**
    * Creates a synthetic error response with proper structure and error details.
    * @param error - The error that occurred
@@ -520,7 +473,7 @@ class T {
     if (r && (s.code = r), o.model === void 0)
       throw new Error("Model must be specified in response parameters for error handling.");
     return {
-      id: this.generateId("error"),
+      id: `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
       created_at: Math.floor(Date.now() / 1e3),
       output_text: "An error occurred while communicating with the language model.",
       error: s,
@@ -530,7 +483,19 @@ class T {
       model: o.model,
       object: "response",
       output: [
-        this.createMessage(`Error: ${e}. Please try again or contact support if the issue persists.`)
+        {
+          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,
@@ -541,153 +506,22 @@ class T {
     };
   }
   /**
-   * 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) {
-    if (this.options.streaming && this.llmAdapter.invokeStream && this.llmAdapter.interpretStream)
-      try {
-        return await this.callLLMStreaming(t);
-      } catch (o) {
-        return console.error("Error calling LLM with streaming:", o), this.options.fallbackToNonStreaming ? (console.warn("Falling back to non-streaming mode"), await this.callLLMNonStreaming(t)) : this.createErrorResponse(o, t);
-      }
-    return await this.callLLMNonStreaming(t);
-  }
-  /**
-   * Calls the LLM in non-streaming mode.
-   * @param responseCreateParams - The parameters for creating the response.
-   * @returns A promise that resolves with the LLM's response.
-   * @private
+   * Calls the LLM adapter to invoke and interpret the response for the given parameters.
+   *
+   * @param {ResponseCreateParamsNonStreaming} responseCreateParams - The parameters for creating the response.
+   * @param {RepositoryUtilities} prepareInitialMessagesArgs - The arguments required to prepare initial messages.
+   * @return {Promise<Response>} A promise that resolves to the interpreted response or an error response in case of failure.
    */
-  async callLLMNonStreaming(t) {
+  async callLLM(t, o) {
     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);
-    }
-  }
-  /**
-   * Calls the LLM in streaming mode, accumulating stream events into a complete response.
-   * @param responseCreateParams - The parameters for creating the response.
-   * @returns A promise that resolves with the accumulated response.
-   * @private
-   */
-  async callLLMStreaming(t) {
-    if (!this.llmAdapter.invokeStream || !this.llmAdapter.interpretStream)
-      throw new Error("Adapter does not support streaming");
-    const o = {
-      ...t,
-      stream: !0
-    }, e = this.llmAdapter.invokeStream(o);
-    let r = {
-      output: [],
-      output_text: ""
-    }, s = 0;
-    for await (const i of e) {
-      const l = await this.llmAdapter.interpretStream(i), h = {
-        responseParams: t,
-        streamIndex: s,
-        accumulatedResponse: r
-      }, a = await this.boothPlugins.runStreamEvent(
-        {
-          toolRegistry: this.toolRegistry,
-          boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins,
-          llmAdapter: this.llmAdapter
-        },
-        l,
-        h
+      const e = await this.llmAdapter.invoke(
+        t,
+        o
       );
-      r = this.mergeStreamEvent(r, a), s++;
-    }
-    return this.finalizeAccumulatedResponse(r, t);
-  }
-  /**
-   * Type guard to check if an output item has a function property (tool call).
-   * @param output - The output item to check
-   * @returns True if the output item is a tool call with a function
-   * @private
-   */
-  isToolCall(t) {
-    return t && "function" in t && t.function && typeof t.function.arguments == "string";
-  }
-  /**
-   * Helper function to safely update tool call arguments.
-   * @param accumulated - The accumulated response
-   * @param callId - The tool call ID to update
-   * @param delta - The argument delta to append
-   * @private
-   */
-  updateToolCallArguments(t, o, e) {
-    if (!t.output) return;
-    const r = t.output.find((s) => s.id === o);
-    this.isToolCall(r) && (r.function.arguments = (r.function.arguments || "") + e);
-  }
-  /**
-   * Helper function to safely update a tool call with final data.
-   * @param accumulated - The accumulated response
-   * @param toolCallData - The final tool call data
-   * @private
-   */
-  updateToolCallFunction(t, o) {
-    if (!t.output || !o?.id || !o?.function) return;
-    const e = t.output.find((r) => r.id === o.id);
-    this.isToolCall(e) && (e.function = o.function);
-  }
-  /**
-   * Merges a stream event into the accumulated response.
-   * @param accumulated - The current accumulated response.
-   * @param streamEvent - The stream event to merge.
-   * @returns The updated accumulated response.
-   * @private
-   */
-  mergeStreamEvent(t, o) {
-    if (!o || !o.type)
-      return t;
-    switch (o.type) {
-      case "text_delta":
-        o.delta && !o.metadata?.call_id ? t.output_text = (t.output_text || "") + o.delta : o.delta && o.metadata?.call_id && typeof o.metadata.call_id == "string" && (t.output = t.output || [], this.updateToolCallArguments(t, o.metadata.call_id, o.delta));
-        break;
-      case "tool_call_start":
-        o.toolCall && (t.output = t.output || [], t.output.push(o.toolCall));
-        break;
-      case "tool_call_end":
-        o.toolCall && (t.output = t.output || [], this.updateToolCallFunction(t, o.toolCall));
-        break;
+      return await this.llmAdapter.interpret(e);
+    } catch (e) {
+      return console.log("Error calling LLM:", e), this.createErrorResponse(e, t);
     }
-    return t;
-  }
-  /**
-   * Creates a complete Response object from accumulated stream data.
-   * @param accumulated - The accumulated response data.
-   * @param originalParams - The original request parameters.
-   * @returns A complete Response object.
-   * @private
-   */
-  finalizeAccumulatedResponse(t, o) {
-    return {
-      id: this.generateId("stream"),
-      created_at: Math.floor(Date.now() / 1e3),
-      output_text: t.output_text || "",
-      error: null,
-      incomplete_details: null,
-      instructions: null,
-      metadata: null,
-      model: o.model || "unknown",
-      object: "response",
-      output: t.output || [
-        this.createMessage(t.output_text || "")
-      ],
-      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: "completed"
-    };
   }
   /**
    * Runs the main interaction loop, sending messages to the LLM and processing
@@ -698,20 +532,27 @@ class T {
    */
   async runInteractionLoop(t) {
     let o = 0, e = t, r, s = !0;
-    for (; s && o < this.loopLimit; )
-      o++, e = await this.boothPlugins.runBeforeMessageSend(
+    for (; s && o < this.loopLimit; ) {
+      o++;
+      const i = this.boothPlugins;
+      e = await this.boothPlugins.runBeforeMessageSend(
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins,
+          pluginRegistry: i,
           llmAdapter: this.llmAdapter
         },
         e
-      ), r = await this.callLLM(e), e = await this.boothPlugins.runResponseReceived(
+      ), r = await this.callLLM(e, {
+        toolRegistry: this.toolRegistry,
+        boothRegistry: this.boothRegistry,
+        pluginRegistry: i,
+        llmAdapter: this.llmAdapter
+      }), e = await this.boothPlugins.runResponseReceived(
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins,
+          pluginRegistry: i,
           llmAdapter: this.llmAdapter
         },
         e,
@@ -720,12 +561,13 @@ class T {
         {
           toolRegistry: this.toolRegistry,
           boothRegistry: this.boothRegistry,
-          pluginRegistry: this.boothPlugins,
+          pluginRegistry: i,
           llmAdapter: this.llmAdapter
         },
         e,
         r
-      ) && (s = !1);
+      ) && (console.log("Ending interaction loop because 'shouldEndInteractionLoop' returned true."), s = !1);
+    }
     if (!r)
       throw new Error("No response received from LLM");
     return r;
@@ -748,35 +590,36 @@ class T {
       input: o,
       tools: []
     };
+    const r = this.boothPlugins;
     e = await this.boothPlugins.runBeforeInteractionLoopStart(
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
-        pluginRegistry: this.boothPlugins,
+        pluginRegistry: r,
         llmAdapter: this.llmAdapter
       },
       e,
       t
     );
-    let r = await this.runInteractionLoop(e);
-    return r = await this.boothPlugins.runAfterInteractionLoopEnd(
+    let s = await this.runInteractionLoop(e);
+    return s = await this.boothPlugins.runAfterInteractionLoopEnd(
       {
         toolRegistry: this.toolRegistry,
         boothRegistry: this.boothRegistry,
-        pluginRegistry: this.boothPlugins,
+        pluginRegistry: r,
         llmAdapter: this.llmAdapter
       },
-      r
-    ), r;
+      s
+    ), s;
   }
 }
-const I = {
+const v = {
   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."
-}, f = "route_to_booth";
-function y(n) {
-  const t = n.getAllBooths(), o = Object.values(t).map(
+}, m = "route_to_booth";
+function b(n) {
+  const t = n.getSelectableBooths(), o = Object.values(t).map(
     (r) => `- ${r.id}: ${r.role}
   Examples:
 ${(r.examples || []).map((s) => `    - "${s}"`).join(`
@@ -785,7 +628,7 @@ ${(r.examples || []).map((s) => `    - "${s}"`).join(`
 `), e = Object.keys(t);
   return {
     type: "function",
-    name: f,
+    name: m,
     description: `
     Routes the conversation to a specialized booth based on the user's needs. Each booth has a 
     specific role and set of capabilities.
@@ -819,14 +662,14 @@ ${o}
           content: `Routed to booth ${r}`
         };
       } catch (s) {
-        return console.error("[routeToBoothTool] Error routing to booth:", s), {
+        return console.log("[routeToBoothTool] Error routing to booth:", s), {
           content: `Error: Unable to route to booth ${r}.`
         };
       }
     }
   };
 }
-class x {
+class I {
   /**
    * 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.
@@ -857,8 +700,8 @@ class x {
    * @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 === 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
+    return t.output ? t.output.some((o) => o.type === "function_call" ? o.name === m : o.type === "message" && "tool_calls" in o && Array.isArray(o.tool_calls) ? o.tool_calls.some(
+      (e) => e.type === "function" && e.function.name === m
     ) : !1) : !1;
   }
   /**
@@ -924,11 +767,18 @@ class x {
     if (this.responseContainsBoothChange(e)) {
       const l = `Please summarize the following conversation history:
 
-${JSON.stringify(this.sessionHistory)}`, g = (await L(t.llmAdapter, I).callProcessor.send(l)).output_text, d = s.filter((c) => "role" in c && c.role === "user").pop(), b = {
+${JSON.stringify(this.sessionHistory)}`, c = (await $(t.llmAdapter, v).callProcessor.send(l)).output, g = s.filter((a) => "role" in a && a.role === "user").pop();
+      console.log("LastUserMessage: ", g), console.log("Summary: ", c), console.log("Summary: ", c.join(""));
+      let f = "";
+      const p = c.find((a) => a.type === "message");
+      console.log("summaryMessages", p), p && "type" in p && p.type == "message" && p.content.forEach((a) => {
+        a.type === "output_text" && (f += a.text);
+      }), console.log("summaryText", f);
+      const R = {
         role: "developer",
-        content: `A conversation summary up to this point: ${g}`
-      }, _ = s.filter((c) => !("role" in c && c.role === "user" || "type" in c && c.type === "message"));
-      this.sessionHistory = d ? [..._, b, d] : [..._, b], s = this.sessionHistory;
+        content: `A conversation summary up to this point: ${f}`
+      }, B = s.filter((a) => !("role" in a && a.role === "user" || "type" in a && a.type === "message"));
+      this.sessionHistory = g ? [...B, R, g] : [...B, R], s = this.sessionHistory;
     } else
       this.sessionHistory = s;
     return {
@@ -1011,7 +861,7 @@ class C {
     return !1;
   }
 }
-class w {
+class _ {
   tools;
   /**
    * Initializes an empty Map to store tools.
@@ -1107,7 +957,7 @@ class w {
     this.tools.delete(t);
   }
 }
-function S(n) {
+function x(n) {
   switch (n.type) {
     case "function":
       return `function:${n.name}`;
@@ -1130,10 +980,10 @@ function S(n) {
       return `${n.type}:${JSON.stringify(n)}`;
   }
 }
-function v(n) {
+function M(n) {
   const t = /* @__PURE__ */ new Set(), o = [];
   for (const e of n) {
-    const r = S(e);
+    const r = x(e);
     t.has(r) || (t.add(r), o.push(e));
   }
   return o;
@@ -1151,18 +1001,18 @@ class A {
    * @returns The updated response parameters with the aggregated list of tools.
    */
   async onBeforeMessageSend(t, o) {
-    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, l = [...e.tools || [], ...r?.tools || []].filter((a, g, d) => d.indexOf(a) === g).map(
-      (a) => t.toolRegistry.getTool(a)
+    const e = t.boothRegistry.baseBoothConfig, r = t.boothRegistry.currentContextBoothConfig, l = [...e.tools || [], ...r?.tools || []].filter((h, c, g) => g.indexOf(h) === c).map(
+      (h) => t.toolRegistry.getTool(h)
     );
     if (e.mcp && l.push(...e.mcp), r?.mcp && l.push(...r.mcp), t.boothRegistry.isMultiBoothMode) {
-      const a = y(t.boothRegistry);
-      l.push(a);
+      const h = b(t.boothRegistry);
+      l.push(h);
     }
     l.push(...t.toolRegistry.getGlobalTools());
-    const h = v(l);
+    const d = M(l);
     return {
       ...o,
-      tools: h
+      tools: d
     };
   }
   /**
@@ -1174,7 +1024,7 @@ class A {
     return !1;
   }
 }
-class m {
+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.";
@@ -1211,13 +1061,15 @@ class m {
         i,
         e
       );
-      return {
+      return l || console.log(
+        `Booths.ToolExecutorPlugin: Tool execution returned an empty results for ${s.name}. This may result in 400 responses from the LLM.`
+      ), {
         type: "function_call_output",
         call_id: r.call_id,
         output: JSON.stringify(l)
       };
     } catch (r) {
-      console.error(`Error executing tool ${o.name}:`, r);
+      console.log(`Error executing tool ${o.name}:`, r);
       const s = await t.pluginRegistry.runToolCallError(
         t,
         o,
@@ -1231,6 +1083,12 @@ class m {
       };
     }
   }
+  /**
+   * Extracts function call objects from an array of response output items.
+   *
+   * @param {ResponseOutputItem[]} output - The array of response output items to filter.
+   * @return {ResponseFunctionToolCall[]} An array containing only the function call objects from the input.
+   */
   static extractFunctionCalls(t) {
     return t.filter(
       (o) => o.type === "function_call"
@@ -1246,21 +1104,21 @@ class m {
    * @returns The updated response parameters, potentially with tool call outputs added to the input.
    */
   async onResponseReceived(t, o, e) {
-    const r = e?.output ?? [], s = m.extractFunctionCalls(r);
+    const r = e?.output ?? [], s = w.extractFunctionCalls(r);
     if (!s.length)
       return o;
     const i = [];
     for (let l = 0; l < s.length; l++) {
-      const h = s[l];
-      if (t.toolRegistry.isLocalTool(h.name))
+      const d = s[l];
+      if (t.toolRegistry.isLocalTool(d.name))
         continue;
-      const a = {
+      const h = {
         responseParams: o,
         response: e,
         toolCallIndex: l,
         totalToolCalls: s.length
-      }, g = await this.executeToolCall(t, h, a);
-      i.push(g);
+      }, c = await this.executeToolCall(t, d, h);
+      i.push(c);
     }
     return {
       ...o,
@@ -1276,13 +1134,16 @@ class m {
     return !1;
   }
 }
-class M {
+class P {
+  constructor(t = "__awaiting_user_response__") {
+    this.marker = t;
+  }
   description = "A plugin to ensure the interaction loop can be finished.";
   id = "finish-turn-plugin";
   name = "Finish Turn Plugin";
   /**
    * 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.
+   * specific marker 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.
@@ -1294,7 +1155,7 @@ class M {
 
  
     [MUST]
-    - Always add the marker "__awaiting_user_response__" at the end of your output when you have finished your part
+    - Always add the marker "${this.marker}" at the end of your output when you have finished your part
     - This marker indicates that the interaction loop should end.
     
     ${e}
@@ -1305,20 +1166,18 @@ class M {
   }
   /**
    * 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.
+   * 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) {
-    if (!e.output_text)
-      return !1;
-    const r = e.output_text.includes("__awaiting_user_response__"), s = e.status === "failed" || e.error !== null;
-    return r || s;
+    const s = JSON.stringify(e.output).includes(this.marker), i = e.status === "failed" || e.error !== null;
+    return s || i;
   }
   /**
-   * After the interaction loop ends, this hook removes the `__awaiting_user_response__` marker
+   * After the interaction loop ends, this hook removes the `marker` marker
    * from the final response before it is returned.
    * @param _ - Unused repository utilities.
    * @param response - The final response from the LLM.
@@ -1326,106 +1185,23 @@ class M {
    */
   async onAfterInteractionLoopEnd(t, o) {
     const e = JSON.stringify(o);
-    if (e.includes("__awaiting_user_response__")) {
-      const r = e.replace(/__awaiting_user_response__/g, "");
+    if (e.includes(this.marker)) {
+      const r = e.replace(new RegExp(this.marker, "g"), "");
       return JSON.parse(r);
     }
     return o;
   }
 }
-class $ {
-  id = "streaming-logger";
-  name = "Streaming Logger Plugin";
-  description = "Logs streaming events in real-time for debugging and monitoring";
-  logPrefix;
-  constructor(t = "[StreamingLogger]") {
-    this.logPrefix = t;
-  }
-  /**
-   * Handle individual stream events as they arrive.
-   * This allows for real-time processing and logging of streaming content.
-   */
-  async onStreamEvent(t, o, e) {
-    switch (o.type) {
-      case "response_start":
-        console.log(`${this.logPrefix} Stream started`);
-        break;
-      case "text_delta":
-        console.log(`${this.logPrefix} Text chunk [${e.streamIndex}]: "${o.delta}"`);
-        break;
-      case "tool_call_start":
-        console.log(`${this.logPrefix} Tool call started: ${o.toolCall?.name}`);
-        break;
-      case "tool_call_end":
-        console.log(`${this.logPrefix} Tool call completed: ${o.toolCall?.name}`);
-        break;
-      case "response_end":
-        console.log(`${this.logPrefix} Stream completed after ${e.streamIndex} events`);
-        break;
-      default:
-        console.log(`${this.logPrefix} Stream event [${e.streamIndex}]: ${o.type}`);
-    }
-    return o;
-  }
-  /**
-   * Required method - determines whether to end the interaction loop.
-   * For a logging plugin, we never want to end the loop ourselves.
-   */
-  async shouldEndInteractionLoop() {
-    return !1;
-  }
-}
-class k {
-  id = "streaming-ui";
-  name = "Streaming UI Plugin";
-  description = "Provides real-time UI updates during streaming responses";
-  onStreamCallback;
-  constructor(t) {
-    this.onStreamCallback = t;
-  }
-  /**
-   * Handle individual stream events and emit them to the UI layer.
-   * This enables real-time updates to the user interface.
-   */
-  async onStreamEvent(t, o, e) {
-    this.onStreamCallback && o.type === "text_delta" && this.onStreamCallback(o, e);
-    let r = o;
-    return o.type === "text_delta" && o.delta && (r = {
-      ...o,
-      // Example: add HTML escaping (though this should be done in the UI layer)
-      delta: o.delta
-    }), r;
-  }
-  /**
-   * Set or update the stream callback for UI updates.
-   */
-  setStreamCallback(t) {
-    this.onStreamCallback = t;
-  }
-  /**
-   * Remove the stream callback.
-   */
-  removeStreamCallback() {
-    this.onStreamCallback = void 0;
-  }
-  /**
-   * Required method - determines whether to end the interaction loop.
-   * For a UI plugin, we never want to end the loop ourselves.
-   */
-  async shouldEndInteractionLoop() {
-    return !1;
-  }
-}
-function L(n, t) {
-  const o = new B(t), e = new w(), r = new p();
-  return new P({
+function $(n, t) {
+  const o = new T(t), e = new _(), r = new y();
+  return new L({
     llmAdapter: n,
     booths: o,
     tools: e,
     boothPlugins: r
   });
 }
-class P {
+class L {
   /**
    * Represents a registry that maintains a collection of plugins for a booth system.
    * The boothPluginRegistry is used to manage and access plugins that enhance
@@ -1480,24 +1256,24 @@ class P {
    * @param {ToolRegistry} options.tools - Registry containing tool configurations
    */
   constructor(t) {
-    if (this.boothPluginRegistry = t?.boothPlugins ?? new p(), this.boothRegistry = t.booths, this.toolRegistry = t?.tools ?? new w(), this.boothRegistry.setMultiBoothModeCallbacks(
+    if (this.boothPluginRegistry = t?.boothPlugins ?? new y(), this.boothRegistry = t.booths, this.toolRegistry = t?.tools ?? new _(), this.boothRegistry.setMultiBoothModeCallbacks(
       () => {
-        const o = y(this.boothRegistry);
+        const o = b(this.boothRegistry);
         this.toolRegistry.registerTools([o]);
       },
       () => {
       }
     ), this.boothRegistry.isMultiBoothMode) {
-      const o = y(this.boothRegistry);
+      const o = b(this.boothRegistry);
       this.toolRegistry.registerTools([o]);
     }
-    this.systemPluginsRegistry = new p(), this.systemPluginsRegistry.registerPlugins([
-      new x(t.sessionHistory),
+    this.systemPluginsRegistry = new y(), this.systemPluginsRegistry.registerPlugins([
+      new I(t.sessionHistory),
       new C(),
       new A(),
-      new m(),
-      new M()
-    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new T(
+      new w(),
+      new P(t.endInteractionLoopMarker)
+    ]), this.systemPluginsRegistry.registerPlugins(this.boothPluginRegistry.getPlugins()), this.callProcessor = new E(
       this.boothRegistry,
       this.systemPluginsRegistry,
       this.toolRegistry,
@@ -1506,18 +1282,16 @@ class P {
   }
 }
 export {
-  p as BoothPluginRegistry,
-  B as BoothRegistry,
+  y as BoothPluginRegistry,
+  T as BoothRegistry,
   C as ContextProviderPlugin,
-  x as ConversationHistoryPlugin,
-  P as CoreBooth,
-  M as FinishTurnPlugin,
-  T as InteractionProcessor,
-  $ as StreamingLoggerPlugin,
-  k as StreamingUIPlugin,
-  m as ToolExecutorPlugin,
+  I as ConversationHistoryPlugin,
+  L as CoreBooth,
+  P as FinishTurnPlugin,
+  E as InteractionProcessor,
+  w as ToolExecutorPlugin,
   A as ToolProviderPlugin,
-  w as ToolRegistry,
-  L as createCoreBooth,
-  y as createRouteToBoothTool
+  _ as ToolRegistry,
+  $ as createCoreBooth,
+  b as createRouteToBoothTool
 };