booths 1.3.0 → 1.4.0

package/README.md

@@ -42,7 +42,7 @@ graph TD
 1.  **Application Layer**: Your application integrates the Booths framework to handle conversational AI interactions.
 2.  **`CoreBooth`**: The framework foundation that provides global functionality, instructions, and infrastructure that applies to all booths. It manages the overall system configuration and coordinates the interaction flow.
 3.  **`InteractionProcessor`**: The engine that drives the conversation. It takes user input, runs it through the plugin lifecycle, sends it to the LLM (via the adapter), and processes the response.
-4.  **`LLMAdapter`**: A component that handles communication with the specific LLM provider (e.g., OpenAI). It translates requests and responses between the Booths system and the LLM's API. Supports both traditional and streaming response modes.
+4.  **`LLMAdapter`**: A component that handles communication with the specific LLM provider (e.g., OpenAI). It translates requests and responses between the Booths system and the LLM's API.
 5.  **Registries**: These are responsible for managing the different components of the system:
     *   `BoothRegistry`: Manages `BoothConfig` objects that define the behavior of different AI agents.
     *   `ToolRegistry`: Manages the tools (functions) that booths can use.
@@ -124,13 +124,7 @@ The `CoreBooth` requires an `LLMAdapter` to communicate with your chosen languag
 
 ```typescript
 // in OpenAIAdapter.ts
-import type { 
-  LLMAdapter, 
-  ResponseCreateParamsNonStreaming, 
-  ResponseCreateParamsStreaming,
-  Response,
-  StreamEvent
-} from 'booths';
+import type { LLMAdapter, ResponseCreateParamsNonStreaming, Response } from 'booths';
 import OpenAI from 'openai';
 
 export class OpenAIAdapter implements LLMAdapter<Response> {
@@ -147,24 +141,6 @@ export class OpenAIAdapter implements LLMAdapter<Response> {
   async interpret(response: Response): Promise<Response> {
     return response;
   }
-
-  // Optional: Add streaming support
-  async *invokeStream(params: ResponseCreateParamsStreaming): AsyncIterable<Response> {
-    const stream = this.openai.responses.create({ ...params, model: 'gpt-4o', stream: true });
-    for await (const chunk of stream) {
-      yield chunk;
-    }
-  }
-
-  async interpretStream(chunk: Response): Promise<StreamEvent> {
-    // Convert OpenAI stream chunks to StreamEvents
-    // Implementation depends on your streaming format
-    return {
-      type: 'text_delta',
-      delta: chunk.choices?.[0]?.delta?.content || '',
-      content: chunk.choices?.[0]?.delta?.content || ''
-    };
-  }
 }
 ```
 
@@ -185,6 +161,11 @@ const llmAdapter = new OpenAIAdapter('your-openai-api-key');
 // 2. Create the CoreBooth instance
 const coreBooth = createCoreBooth(llmAdapter, pirateBooth);
 
+// Optional: Customize the end interaction loop marker
+// const coreBooth = createCoreBooth(llmAdapter, pirateBooth, {
+//   endInteractionLoopMarker: '__custom_marker__'
+// });
+
 // 3. Register the tool (this step will be improved in future versions)
 coreBooth.toolRegistry.registerTools([tellPirateJokeTool]);
 
@@ -219,7 +200,6 @@ Plugins are classes that implement the `BoothPlugin` interface. They can execute
 - `onBeforeToolCall`: Before each individual tool call is executed _(allows modification of tool parameters, validation, and logging)_.
 - `onAfterToolCall`: After each individual tool call is successfully executed _(allows result processing, caching, and transformation)_.
 - `onToolCallError`: When a tool call encounters an error _(allows custom error handling and recovery)_.
-- `onStreamEvent`: _(Optional)_ During streaming response generation, called for each stream event _(enables real-time processing and UI updates)_.
 - `shouldEndInteractionLoop`: To determine if the conversation turn is over.
 - `onAfterInteractionLoopEnd`: After the main loop has finished.
 
@@ -229,7 +209,7 @@ The system includes several core plugins by default:
 - `ContextProviderPlugin`: Provides the LLM with the context of the current booth.
 - `ToolProviderPlugin`: Provides the LLM with the available tools for the current booth.
 - `ToolExecutorPlugin`: Executes tool calls requested by the LLM with granular hook support for individual tool call interception.
-- `FinishTurnPlugin`: Determines when the LLM's turn is finished and it's waiting for user input.
+- `FinishTurnPlugin`: Determines when the LLM's turn is finished and it's waiting for user input. The marker used to detect conversation end can be customized via the `endInteractionLoopMarker` option (defaults to `__awaiting_user_response__`).
 
 #### Enhanced Tool Call Management
 
@@ -252,245 +232,3 @@ The `InteractionProcessor` is the engine of the system. It manages the interacti
 5. Runs the `onResponseReceived` plugin hooks to process the response (e.g., execute tools).
 6. Repeats this loop until a plugin's `shouldEndInteractionLoop` returns `true`.
 7. Runs the `onAfter...` plugin hooks for cleanup.
-
-## Streaming Support
-
-The Booths framework includes comprehensive streaming support that enables real-time response generation while preserving the full plugin ecosystem and backward compatibility.
-
-### Overview
-
-Streaming allows the LLM's response to be processed and displayed in real-time as it's being generated, providing a more responsive user experience. The framework handles streaming at multiple levels:
-
-- **Real-time Events**: Stream events are emitted as content arrives
-- **Plugin Integration**: Plugins can hook into streaming events for real-time processing
-- **Complete Responses**: Existing plugins continue to receive complete responses
-- **Automatic Fallback**: Graceful fallback to non-streaming if streaming fails
-
-### Enabling Streaming
-
-Streaming can be enabled simply by setting a boolean flag when creating the `InteractionProcessor`:
-
-```typescript
-import { InteractionProcessor, type InteractionProcessorOptions } from 'booths';
-
-const options: InteractionProcessorOptions = {
-  streaming: true,                    // Enable streaming
-  fallbackToNonStreaming: true       // Optional: fallback if streaming fails
-};
-
-const processor = new InteractionProcessor(
-  boothRegistry,
-  pluginRegistry, 
-  toolRegistry,
-  llmAdapter,      // Must implement streaming methods
-  options
-);
-```
-
-### Stream Events
-
-The streaming system emits different types of events as the response is generated:
-
-```typescript
-export interface StreamEvent {
-  type: 'text_delta' | 'tool_call_start' | 'tool_call_end' | 'response_start' | 'response_end';
-  content?: string;      // Full content for text events
-  delta?: string;        // Incremental text for text_delta events  
-  toolCall?: object;     // Tool call information
-  metadata?: any;        // Additional event metadata
-}
-```
-
-**Event Types:**
-- `response_start`: Streaming begins
-- `text_delta`: Incremental text content arrives
-- `tool_call_start`: LLM begins a tool call
-- `tool_call_end`: Tool call completes
-- `response_end`: Streaming completes
-
-### Streaming Plugin Hooks
-
-Plugins can implement the optional `onStreamEvent` hook to process stream events in real-time:
-
-```typescript
-import type { BoothPlugin, StreamEvent, StreamContext, RepositoryUtilities } from 'booths';
-
-export class MyStreamingPlugin implements BoothPlugin {
-  id = 'my-streaming-plugin';
-  name = 'My Streaming Plugin';
-  description = 'Handles streaming events';
-
-  async onStreamEvent(
-    utilities: RepositoryUtilities,
-    streamEvent: StreamEvent,
-    context: StreamContext
-  ): Promise<StreamEvent> {
-    // Process the stream event
-    if (streamEvent.type === 'text_delta') {
-      console.log(`Received text: ${streamEvent.delta}`);
-      
-      // Optionally transform the event
-      return {
-        ...streamEvent,
-        delta: streamEvent.delta?.toUpperCase()  // Example transformation
-      };
-    }
-    
-    return streamEvent;  // Pass through unchanged
-  }
-
-  async shouldEndInteractionLoop(): Promise<boolean> {
-    return false;
-  }
-}
-```
-
-### Built-in Streaming Plugins
-
-The framework includes example streaming plugins:
-
-#### StreamingLoggerPlugin
-
-Logs streaming events in real-time for debugging and monitoring:
-
-```typescript
-import { StreamingLoggerPlugin } from 'booths';
-
-const logger = new StreamingLoggerPlugin('[MyApp]');
-pluginRegistry.registerPlugins([logger]);
-```
-
-#### StreamingUIPlugin  
-
-Provides real-time UI updates with customizable callbacks:
-
-```typescript
-import { StreamingUIPlugin } from 'booths';
-
-const uiPlugin = new StreamingUIPlugin((event, context) => {
-  if (event.type === 'text_delta') {
-    // Update your UI with the new text
-    document.getElementById('response').textContent += event.delta;
-  }
-});
-
-pluginRegistry.registerPlugins([uiPlugin]);
-```
-
-### LLM Adapter Streaming Implementation
-
-To support streaming, your LLM adapter should implement the optional streaming methods:
-
-```typescript
-export class MyStreamingAdapter implements LLMAdapter<MyResponse> {
-  // Required methods
-  async invoke(params: ResponseCreateParamsNonStreaming): Promise<MyResponse> {
-    // Non-streaming implementation
-  }
-
-  async interpret(response: MyResponse): Promise<Response> {
-    // Convert to standard format
-  }
-
-  // Optional streaming methods
-  async *invokeStream(params: ResponseCreateParamsStreaming): AsyncIterable<MyResponse> {
-    // Yield streaming chunks
-    const stream = await this.llm.createStreamingResponse(params);
-    for await (const chunk of stream) {
-      yield chunk;
-    }
-  }
-
-  async interpretStream(chunk: MyResponse): Promise<StreamEvent> {
-    // Convert chunk to StreamEvent
-    return {
-      type: 'text_delta',
-      delta: chunk.delta,
-      content: chunk.content
-    };
-  }
-}
-```
-
-### Stream Context
-
-Plugins receive context information about the streaming session:
-
-```typescript
-export interface StreamContext {
-  responseParams: ResponseCreateParamsNonStreaming;  // Original request
-  streamIndex: number;                               // Event index in stream  
-  totalExpectedEvents?: number;                      // Expected total (if known)
-  accumulatedResponse: Partial<Response>;            // Response built so far
-}
-```
-
-### Error Handling
-
-The streaming system includes robust error handling:
-
-- **Plugin Error Isolation**: Errors in streaming plugins don't break the stream
-- **Automatic Fallback**: Can fallback to non-streaming mode on errors
-- **Graceful Degradation**: System continues operating if streaming fails
-
-### Backward Compatibility
-
-Streaming support is fully backward compatible:
-
-- **Existing Plugins**: Continue to work unchanged
-- **Complete Responses**: Plugins still receive full `Response` objects  
-- **Optional Implementation**: Adapters don't require streaming support
-- **Default Behavior**: Non-streaming mode by default
-
-### Example: Complete Streaming Setup
-
-Here's a complete example showing streaming integration:
-
-```typescript
-import { 
-  InteractionProcessor,
-  BoothRegistry,
-  BoothPluginRegistry,
-  ToolRegistry,
-  StreamingLoggerPlugin, 
-  StreamingUIPlugin,
-  type InteractionProcessorOptions 
-} from 'booths';
-
-// 1. Create streaming-enabled adapter (implement streaming methods)
-const streamingAdapter = new MyStreamingLLMAdapter(apiKey);
-
-// 2. Set up registries and booth
-const testBooth = { id: 'chat-booth', role: 'Assistant', description: 'Helpful assistant' };
-const boothRegistry = new BoothRegistry(testBooth);
-const pluginRegistry = new BoothPluginRegistry();
-const toolRegistry = new ToolRegistry();
-
-// 3. Set up streaming plugins
-const logger = new StreamingLoggerPlugin('[Chat]');
-const uiUpdater = new StreamingUIPlugin((event) => {
-  if (event.type === 'text_delta') {
-    document.getElementById('chat').textContent += event.delta;
-  }
-});
-
-pluginRegistry.registerPlugins([logger, uiUpdater]);
-
-// 4. Enable streaming
-const streamingOptions: InteractionProcessorOptions = {
-  streaming: true,
-  fallbackToNonStreaming: true
-};
-
-const processor = new InteractionProcessor(
-  boothRegistry,
-  pluginRegistry, 
-  toolRegistry,
-  streamingAdapter,
-  streamingOptions
-);
-
-// 5. Send message with real-time streaming
-const response = await processor.send('Hello, stream this response!');
-// User sees content appear in real-time, plugins receive complete response
-```

package/dist/index.d.ts

@@ -120,9 +120,9 @@ export declare interface BoothPlugin {
      * @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 The potentially modified tool call result.
+     * @returns The potentially modified tool call result, otherwise the original result.
      */
-    onAfterToolCall?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, result: unknown, context: ToolCallContext) => Promise<unknown>;
+    onAfterToolCall?: (utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, result: unknown, context: ToolCallContext) => Promise<typeof result>;
     /**
      * Called when an individual tool call encounters an error during execution.
      * This allows for custom error handling or recovery.
@@ -150,15 +150,6 @@ export declare interface BoothPlugin {
      * @returns The potentially modified final response.
      */
     onAfterInteractionLoopEnd?: (interactionLoopEndArgs: RepositoryUtilities, response: Response_2) => Promise<Response_2>;
-    /**
-     * Called for each streaming event as it arrives during response generation.
-     * This is optional and only called when streaming is enabled.
-     * @param utilities - Utilities for accessing repositories.
-     * @param streamEvent - The streaming event that was received.
-     * @param context - Context information about the streaming session.
-     * @returns The potentially modified stream event, or void to pass through unchanged.
-     */
-    onStreamEvent?: (utilities: RepositoryUtilities, streamEvent: StreamEvent, context: StreamContext) => Promise<StreamEvent | void>;
 }
 
 /**
@@ -302,17 +293,6 @@ export declare class BoothPluginRegistry {
      * @returns Error result or recovery value after all plugins have processed it
      */
     runToolCallError(utilities: RepositoryUtilities, toolCall: ResponseFunctionToolCall, error: Error, context: ToolCallContext): Promise<any>;
-    /**
-     * 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
-     */
-    runStreamEvent(utilities: RepositoryUtilities, streamEvent: StreamEvent, context: StreamContext): Promise<StreamEvent>;
 }
 
 /**
@@ -695,6 +675,7 @@ export declare class CoreBooth<T> {
         tools?: ToolRegistry;
         llmAdapter: LLMAdapter<T>;
         sessionHistory?: ResponseInput;
+        endInteractionLoopMarker?: string;
     });
 }
 
@@ -724,12 +705,14 @@ export declare function createRouteToBoothTool(boothRegistry: BoothRegistry): To
  * in the LLM's response. It also cleans up this marker before the final output is returned.
  */
 export declare class FinishTurnPlugin implements BoothPlugin {
+    private marker;
     description: string;
     id: string;
     name: string;
+    constructor(marker?: string);
     /**
      * 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.
@@ -759,7 +742,7 @@ export declare class FinishTurnPlugin implements BoothPlugin {
     }>;
     /**
      * 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.
@@ -767,7 +750,7 @@ export declare class FinishTurnPlugin implements BoothPlugin {
      */
     shouldEndInteractionLoop(_: RepositoryUtilities, __: ResponseCreateParamsNonStreaming, response: Response_2): Promise<boolean>;
     /**
-     * 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.
@@ -777,30 +760,19 @@ export declare class FinishTurnPlugin implements BoothPlugin {
 }
 
 /**
- * The InteractionProcessor class orchestrates the conversation with the LLM,
- * managing the interaction loop, plugin execution, and message passing.
+ * A class responsible for processing interactions with a language learning model (LLM)
+ * by delegating tasks to a plugin-enabled architecture.
+ * This class manages the process of sending messages to an LLM,
+ * invoking plugins, handling errors, and iterating through responses.
+ *
+ * @template T The type used in the LLMAdapter for communicating with the LLM.
  */
 export declare class InteractionProcessor<T> {
     private boothRegistry;
     private boothPlugins;
     private toolRegistry;
     private llmAdapter;
-    /**
-     * 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
-     */
-    private generateId;
-    /**
-     * Creates a standardized message object for responses.
-     * @param text - The text content for the message
-     * @returns A formatted message object
-     * @private
-     */
-    private createMessage;
     private loopLimit;
-    private options;
     /**
      * Creates a synthetic error response with proper structure and error details.
      * @param error - The error that occurred
@@ -810,42 +782,13 @@ export declare class InteractionProcessor<T> {
      */
     private createErrorResponse;
     /**
-     * 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
+     * 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.
      */
     private callLLM;
-    /**
-     * 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
-     */
-    private callLLMNonStreaming;
-    /**
-     * 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
-     */
-    private callLLMStreaming;
-    /**
-     * 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
-     */
-    private mergeStreamEvent;
-    /**
-     * 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
-     */
-    private finalizeAccumulatedResponse;
     /**
      * Runs the main interaction loop, sending messages to the LLM and processing
      * the responses through the registered plugins.
@@ -860,9 +803,8 @@ export declare class InteractionProcessor<T> {
      * @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(boothRegistry: BoothRegistry, boothPlugins: BoothPluginRegistry, toolRegistry: ToolRegistry, llmAdapter: LLMAdapter<T>, options?: InteractionProcessorOptions);
+    constructor(boothRegistry: BoothRegistry, boothPlugins: BoothPluginRegistry, toolRegistry: ToolRegistry, llmAdapter: LLMAdapter<T>);
     /**
      * 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.
@@ -873,22 +815,14 @@ export declare class InteractionProcessor<T> {
 }
 
 /**
- * Configuration options for the InteractionProcessor.
+ * Interface representing a Large Language Model (LLM) Adapter that provides methods
+ * to interact with and interpret responses from an LLM.
+ *
+ * @template LLMResponse The type of the raw response returned by the LLM. Defaults to `any`.
  */
-export declare interface InteractionProcessorOptions {
-    /** Enable streaming mode for LLM responses */
-    streaming?: boolean;
-    /** Fallback to non-streaming if streaming fails */
-    fallbackToNonStreaming?: boolean;
-}
-
 export declare interface LLMAdapter<LLMResponse = any> {
-    invoke: (responseParams: ResponseCreateParamsNonStreaming) => Promise<LLMResponse>;
+    invoke: (responseParams: ResponseCreateParamsNonStreaming, prepareInitialMessagesArgs: RepositoryUtilities) => Promise<LLMResponse>;
     interpret: (response: LLMResponse) => Promise<Response_2>;
-    /** Optional method for streaming LLM responses */
-    invokeStream?: (responseParams: ResponseCreateParamsStreaming) => AsyncIterable<LLMResponse>;
-    /** Optional method for interpreting individual stream chunks into StreamEvents */
-    interpretStream?: (streamChunk: LLMResponse) => Promise<StreamEvent>;
 }
 
 /**
@@ -912,24 +846,8 @@ export declare type RepositoryUtilities = {
     llmAdapter: LLMAdapter<unknown>;
 };
 
-export { Response_2 as Response }
-
 export { ResponseCreateParamsNonStreaming }
 
-/**
- * Response parameters for streaming requests.
- * This creates a new type that has all the properties of ResponseCreateParamsNonStreaming
- * but with stream: true instead of stream: false.
- */
-export declare type ResponseCreateParamsStreaming = Omit<ResponseCreateParamsNonStreaming, 'stream'> & {
-    /** Must be true for streaming requests */
-    stream: true;
-};
-
-export { ResponseInput }
-
-export { ResponseInputItem }
-
 /**
  * Represents the result of processing a single tool call.
  */
@@ -950,93 +868,6 @@ export declare type SingleToolProcessingResult = {
     toolExecuted: boolean;
 };
 
-/**
- * Context information provided during streaming event processing.
- */
-export declare interface StreamContext {
-    /** The current response parameters being processed */
-    responseParams: ResponseCreateParamsNonStreaming;
-    /** Index of this stream event in the sequence */
-    streamIndex: number;
-    /** Total expected number of events (if known) */
-    totalExpectedEvents?: number;
-    /** Accumulated response content so far */
-    accumulatedResponse: Partial<Response_2>;
-}
-
-/**
- * Represents a streaming event emitted during LLM response generation.
- */
-export declare interface StreamEvent {
-    /** Type of stream event */
-    type: 'text_delta' | 'tool_call_start' | 'tool_call_end' | 'response_start' | 'response_end';
-    /** Text content for text_delta events */
-    content?: string;
-    /** Incremental text delta for text_delta events */
-    delta?: string;
-    /** Tool call information for tool-related events */
-    toolCall?: ResponseFunctionToolCall;
-    /** Additional metadata for the event */
-    metadata?: Record<string, unknown>;
-}
-
-/**
- * Callback function type for handling stream events in the UI.
- */
-export declare type StreamEventCallback = (event: StreamEvent, context: StreamContext) => void;
-
-/**
- * Example streaming plugin that logs stream events in real-time.
- * This demonstrates how to implement streaming hooks in plugins.
- */
-export declare class StreamingLoggerPlugin implements BoothPlugin {
-    readonly id = "streaming-logger";
-    readonly name = "Streaming Logger Plugin";
-    readonly description = "Logs streaming events in real-time for debugging and monitoring";
-    private logPrefix;
-    constructor(logPrefix?: string);
-    /**
-     * Handle individual stream events as they arrive.
-     * This allows for real-time processing and logging of streaming content.
-     */
-    onStreamEvent(_utilities: RepositoryUtilities, streamEvent: StreamEvent, context: StreamContext): Promise<StreamEvent>;
-    /**
-     * Required method - determines whether to end the interaction loop.
-     * For a logging plugin, we never want to end the loop ourselves.
-     */
-    shouldEndInteractionLoop(): Promise<boolean>;
-}
-
-/**
- * Example streaming plugin that provides real-time UI updates.
- * This plugin demonstrates how to emit stream events to the UI layer.
- */
-export declare class StreamingUIPlugin implements BoothPlugin {
-    readonly id = "streaming-ui";
-    readonly name = "Streaming UI Plugin";
-    readonly description = "Provides real-time UI updates during streaming responses";
-    private onStreamCallback?;
-    constructor(onStreamCallback?: StreamEventCallback);
-    /**
-     * Handle individual stream events and emit them to the UI layer.
-     * This enables real-time updates to the user interface.
-     */
-    onStreamEvent(_utilities: RepositoryUtilities, streamEvent: StreamEvent, context: StreamContext): Promise<StreamEvent>;
-    /**
-     * Set or update the stream callback for UI updates.
-     */
-    setStreamCallback(callback: StreamEventCallback): void;
-    /**
-     * Remove the stream callback.
-     */
-    removeStreamCallback(): void;
-    /**
-     * Required method - determines whether to end the interaction loop.
-     * For a UI plugin, we never want to end the loop ourselves.
-     */
-    shouldEndInteractionLoop(): Promise<boolean>;
-}
-
 /**
  * Context information provided during tool call execution.
  */