@tylertech/forge-ai 0.15.3-dev.0 → 0.16.0-dev.0

package/dist/ai-chatbot/agent-adapter.mjs

@@ -1,221 +0,0 @@
-import { EventEmitter } from "./event-emitter.mjs";
-class AgentAdapter {
-  constructor() {
-    this._state = { isConnected: false, isConnecting: false, isRunning: false };
-    this._tools = [];
-    this._events = {
-      runStarted: new EventEmitter(),
-      runFinished: new EventEmitter(),
-      runAborted: new EventEmitter(),
-      messageStart: new EventEmitter(),
-      messageDelta: new EventEmitter(),
-      messageEnd: new EventEmitter(),
-      toolCall: new EventEmitter(),
-      toolCallStart: new EventEmitter(),
-      toolCallArgs: new EventEmitter(),
-      toolCallEnd: new EventEmitter(),
-      toolResult: new EventEmitter(),
-      mcpUiResource: new EventEmitter(),
-      fileUpload: new EventEmitter(),
-      fileRemove: new EventEmitter(),
-      error: new EventEmitter(),
-      stateChange: new EventEmitter(),
-      customEvent: new EventEmitter(),
-      rawEvent: new EventEmitter(),
-      runStartedEvent: new EventEmitter(),
-      stepStarted: new EventEmitter(),
-      stepFinished: new EventEmitter(),
-      stateSnapshot: new EventEmitter(),
-      stateDelta: new EventEmitter(),
-      activitySnapshot: new EventEmitter(),
-      activityDelta: new EventEmitter()
-    };
-  }
-  setTools(tools) {
-    this._tools = tools;
-  }
-  getTools() {
-    return [...this._tools];
-  }
-  /**
-   * Tools to forward to the backend agent, excluding MCP-app tools (`ToolDefinition.mcpApp`).
-   * MCP-app tools are a host-internal mechanism for streaming a UI resource into an existing
-   * tool call — the model never calls them directly, so they must never reach the agent.
-   */
-  getModelFacingTools() {
-    return this._tools.filter((tool) => tool.mcpApp === void 0);
-  }
-  getState() {
-    return { ...this._state };
-  }
-  get isConnected() {
-    return this._state.isConnected;
-  }
-  get isConnecting() {
-    return this._state.isConnecting;
-  }
-  get isRunning() {
-    return this._state.isRunning;
-  }
-  onRunStarted(callback) {
-    return this._events.runStarted.subscribe(callback);
-  }
-  onRunFinished(callback) {
-    return this._events.runFinished.subscribe(callback);
-  }
-  onRunAborted(callback) {
-    return this._events.runAborted.subscribe(callback);
-  }
-  onMessageStart(callback) {
-    return this._events.messageStart.subscribe(callback);
-  }
-  onMessageDelta(callback) {
-    return this._events.messageDelta.subscribe(callback);
-  }
-  onMessageEnd(callback) {
-    return this._events.messageEnd.subscribe(callback);
-  }
-  onToolCall(callback) {
-    return this._events.toolCall.subscribe(callback);
-  }
-  onToolCallStart(callback) {
-    return this._events.toolCallStart.subscribe(callback);
-  }
-  onToolCallArgs(callback) {
-    return this._events.toolCallArgs.subscribe(callback);
-  }
-  onToolCallEnd(callback) {
-    return this._events.toolCallEnd.subscribe(callback);
-  }
-  onToolCallResult(callback) {
-    return this._events.toolResult.subscribe(callback);
-  }
-  onMcpUiResource(callback) {
-    return this._events.mcpUiResource.subscribe(callback);
-  }
-  onFileUpload(callback) {
-    return this._events.fileUpload.subscribe(callback);
-  }
-  onFileRemove(callback) {
-    return this._events.fileRemove.subscribe(callback);
-  }
-  onError(callback) {
-    return this._events.error.subscribe(callback);
-  }
-  onStateChange(callback) {
-    return this._events.stateChange.subscribe(callback);
-  }
-  onCustomEvent(callback) {
-    return this._events.customEvent.subscribe(callback);
-  }
-  onRawEvent(callback) {
-    return this._events.rawEvent.subscribe(callback);
-  }
-  onRunStartedEvent(callback) {
-    return this._events.runStartedEvent.subscribe(callback);
-  }
-  onStepStarted(callback) {
-    return this._events.stepStarted.subscribe(callback);
-  }
-  onStepFinished(callback) {
-    return this._events.stepFinished.subscribe(callback);
-  }
-  onStateSnapshot(callback) {
-    return this._events.stateSnapshot.subscribe(callback);
-  }
-  onStateDelta(callback) {
-    return this._events.stateDelta.subscribe(callback);
-  }
-  onActivitySnapshot(callback) {
-    return this._events.activitySnapshot.subscribe(callback);
-  }
-  onActivityDelta(callback) {
-    return this._events.activityDelta.subscribe(callback);
-  }
-  _emitRunStarted() {
-    this._events.runStarted.emit();
-  }
-  _emitRunFinished() {
-    this._events.runFinished.emit();
-  }
-  _emitRunAborted() {
-    this._events.runAborted.emit();
-  }
-  _emitMessageStart(messageId, rawEvent) {
-    this._events.messageStart.emit({ messageId, rawEvent });
-  }
-  _emitMessageDelta(messageId, delta, rawEvent) {
-    this._events.messageDelta.emit({ messageId, delta, rawEvent });
-  }
-  _emitMessageEnd(messageId, rawEvent) {
-    this._events.messageEnd.emit({ messageId, rawEvent });
-  }
-  _emitToolCall(event, rawEvent) {
-    this._events.toolCall.emit({ ...event, rawEvent });
-  }
-  _emitToolCallStart(event, rawEvent) {
-    this._events.toolCallStart.emit({ ...event, rawEvent });
-  }
-  _emitToolCallArgs(event, rawEvent) {
-    this._events.toolCallArgs.emit({ ...event, rawEvent });
-  }
-  _emitToolCallEnd(event, rawEvent) {
-    this._events.toolCallEnd.emit({ ...event, rawEvent });
-  }
-  _emitToolResult(event, rawEvent) {
-    this._events.toolResult.emit({ ...event, rawEvent });
-  }
-  /**
-   * Announce that a tool call renders as an MCP-app widget. Also the way to remount
-   * widgets restored from history: call it per widget after `setMessages`/`setThreadState`
-   * — the resource is resolved and stamped onto the restored (already finalized) tool
-   * call. If the tool call isn't in state yet, the resource is held and applied when it
-   * arrives.
-   */
-  _emitMcpUiResource(event, rawEvent) {
-    this._events.mcpUiResource.emit({ ...event, rawEvent });
-  }
-  emitFileUpload(file, callbacks) {
-    this._events.fileUpload.emit({ file, ...callbacks });
-  }
-  emitFileRemove(fileId, callbacks) {
-    this._events.fileRemove.emit({ fileId, ...callbacks });
-  }
-  _emitError(message) {
-    this._events.error.emit({ message });
-  }
-  _emitCustomEvent(name, value, rawEvent) {
-    this._events.customEvent.emit({ name, value, rawEvent });
-  }
-  _emitRawEvent(event, rawEvent) {
-    this._events.rawEvent.emit({ event, rawEvent });
-  }
-  _emitRunStartedEvent(threadId, runId, rawEvent) {
-    this._events.runStartedEvent.emit({ threadId, runId, rawEvent });
-  }
-  _emitStepStarted(stepName, rawEvent) {
-    this._events.stepStarted.emit({ stepName, rawEvent });
-  }
-  _emitStepFinished(stepName, rawEvent) {
-    this._events.stepFinished.emit({ stepName, rawEvent });
-  }
-  _emitStateSnapshot(state, rawEvent) {
-    this._events.stateSnapshot.emit({ state, rawEvent });
-  }
-  _emitStateDelta(delta, rawEvent) {
-    this._events.stateDelta.emit({ delta, rawEvent });
-  }
-  _emitActivitySnapshot(activity, activityMessage, existingMessage, rawEvent) {
-    this._events.activitySnapshot.emit({ activity, activityMessage, existingMessage, rawEvent });
-  }
-  _emitActivityDelta(delta, activityMessage, rawEvent) {
-    this._events.activityDelta.emit({ delta, activityMessage, rawEvent });
-  }
-  _updateState(updates) {
-    this._state = { ...this._state, ...updates };
-    this._events.stateChange.emit(this.getState());
-  }
-}
-export {
-  AgentAdapter
-};

package/dist/ai-chatbot/agent-runner.d.ts

@@ -1,41 +0,0 @@
-import { AgentAdapter } from './agent-adapter.js';
-import { ChatMessage, ToolCall, ToolDefinition } from './types.js';
-export interface AgentRunnerConfig {
-    /** The adapter instance that handles communication with the AI model */
-    adapter: AgentAdapter;
-    /** The user prompt to send to the agent */
-    prompt: string;
-    /** Optional tools the agent can call during execution */
-    tools?: ToolDefinition[];
-    /** Execution mode: 'one-shot' stops after first response, 'multi-turn' allows tool usage loops. @default 'one-shot' */
-    mode?: 'one-shot' | 'multi-turn';
-    /** Maximum conversation turns in multi-turn mode to prevent infinite loops. @default 20 */
-    maxTurns?: number;
-    /** Callback fired when agent starts generating a new message */
-    onStart?: (messageId: string) => void;
-    /** Callback fired for each text chunk as it streams in */
-    onDelta?: (delta: string) => void;
-    /** Callback fired when agent requests a tool call */
-    onToolCall?: (toolCall: ToolCall) => void;
-    /** Callback fired when execution completes with final result */
-    onComplete?: (result: AgentRunnerResult) => void;
-}
-export interface AgentRunnerResult {
-    /** Complete message history including user, assistant, and tool messages */
-    messages: ChatMessage[];
-    /** The final assistant message returned by the agent */
-    finalMessage: ChatMessage;
-    /** All tool calls executed during the conversation */
-    toolCalls: ToolCall[];
-    /** Number of conversation turns completed */
-    turns: number;
-    /** Whether execution completed successfully without errors */
-    success: boolean;
-    /** Reason execution stopped: 'text-response' (natural completion), 'max-turns' (hit turn limit), 'error' (failed), or 'one-shot-complete' (single turn mode) */
-    stoppedReason: 'text-response' | 'max-turns' | 'error' | 'one-shot-complete';
-}
-export declare class AgentRunner {
-    #private;
-    private constructor();
-    static run(config: AgentRunnerConfig): Promise<AgentRunnerResult>;
-}

package/dist/ai-chatbot/agent-runner.mjs

@@ -1,265 +0,0 @@
-import { SubscriptionManager } from "./event-emitter.mjs";
-import { generateId } from "./utils.mjs";
-class AgentRunner {
-  constructor() {
-  }
-  static async run(config) {
-    const {
-      adapter,
-      tools,
-      prompt,
-      mode = "one-shot",
-      maxTurns = 20,
-      onStart,
-      onDelta,
-      onToolCall,
-      onComplete
-    } = config;
-    await this.#ensureConnected(adapter);
-    if (tools) {
-      adapter.setTools(tools);
-    }
-    const userMessage = this.#createUserMessage(prompt);
-    return this.#executePrompt(adapter, userMessage, tools, mode, maxTurns, {
-      onStart,
-      onDelta,
-      onToolCall,
-      onComplete
-    });
-  }
-  static #executePrompt(adapter, userMessage, tools, mode, maxTurns, callbacks) {
-    return new Promise((resolve, reject) => {
-      const state = {
-        mode,
-        maxTurns,
-        turns: 0,
-        messages: [userMessage],
-        currentMessage: null,
-        toolCalls: [],
-        toolResultMessages: /* @__PURE__ */ new Map(),
-        pendingToolExecutions: /* @__PURE__ */ new Set(),
-        runFinished: false,
-        hasTextResponse: false,
-        hasErrors: false,
-        resolved: false,
-        subscriptions: new SubscriptionManager(),
-        onToolCall: callbacks.onToolCall,
-        resolve,
-        reject
-      };
-      state.subscriptions.add(
-        adapter.onMessageStart(this.#createMessageStartHandler(state, callbacks.onStart)),
-        adapter.onMessageDelta(this.#createMessageDeltaHandler(state, callbacks.onDelta)),
-        adapter.onRunFinished(this.#createFinishHandler(state, callbacks.onComplete)),
-        adapter.onError(this.#createErrorHandler(state)),
-        adapter.onToolCall(this.#createToolCallHandler(adapter, tools, state))
-      );
-      adapter.sendMessage([userMessage]);
-    });
-  }
-  static async #ensureConnected(adapter) {
-    if (!adapter.isConnected) {
-      await adapter.connect();
-    }
-  }
-  static #createUserMessage(prompt) {
-    return {
-      id: generateId(),
-      role: "user",
-      content: prompt,
-      timestamp: Date.now(),
-      status: "complete"
-    };
-  }
-  static #createMessageStartHandler(state, onStart) {
-    return (event) => {
-      state.turns++;
-      state.currentMessage = {
-        id: event.messageId,
-        role: "assistant",
-        content: "",
-        timestamp: Date.now(),
-        status: "streaming"
-      };
-      onStart?.(event.messageId);
-    };
-  }
-  static #createMessageDeltaHandler(state, onDelta) {
-    return (event) => {
-      if (state.currentMessage) {
-        state.currentMessage.content = (state.currentMessage.content ?? "") + event.delta;
-        if (event.delta.trim().length > 0) {
-          state.hasTextResponse = true;
-        }
-        onDelta?.(event.delta);
-      }
-    };
-  }
-  static #createFinishHandler(state, onComplete) {
-    return () => {
-      state.runFinished = true;
-      this.#tryFinish(state, onComplete);
-    };
-  }
-  static #createErrorHandler(state) {
-    return (event) => {
-      if (state.resolved) {
-        return;
-      }
-      state.resolved = true;
-      state.subscriptions.unsubscribe();
-      state.reject(new Error(event.message));
-    };
-  }
-  static #createToolCallHandler(adapter, tools, state) {
-    return async (event) => {
-      await this.#executeToolCall(event, tools, state, adapter);
-    };
-  }
-  static #createToolResponse(toolName, handlerReturn) {
-    if (typeof handlerReturn === "string") {
-      return handlerReturn;
-    }
-    if (handlerReturn && typeof handlerReturn === "object") {
-      return handlerReturn;
-    }
-    return `Tool '${toolName}' executed successfully`;
-  }
-  static #buildMessageHistory(state) {
-    const messages = [...state.messages];
-    if (state.currentMessage) {
-      const assistantMessage = {
-        ...state.currentMessage,
-        status: "complete",
-        toolCalls: state.toolCalls.filter((tc) => tc.messageId === state.currentMessage?.id)
-      };
-      messages.push(assistantMessage);
-    }
-    for (const toolCall of state.toolCalls) {
-      if (toolCall.status === "complete" || toolCall.status === "error") {
-        let toolMessage = state.toolResultMessages.get(toolCall.id);
-        if (!toolMessage) {
-          toolMessage = {
-            id: generateId(),
-            role: "tool",
-            content: JSON.stringify(toolCall.result),
-            timestamp: Date.now(),
-            status: "complete",
-            toolCallId: toolCall.id
-          };
-          state.toolResultMessages.set(toolCall.id, toolMessage);
-        }
-        messages.push(toolMessage);
-      }
-    }
-    return messages;
-  }
-  static async #executeToolCall(event, tools, state, adapter) {
-    const execution = (async () => {
-      let result;
-      const toolDef = tools?.find((t) => t.name === event.name);
-      const toolCall = {
-        id: event.id,
-        messageId: state.currentMessage?.id ?? "",
-        name: event.name,
-        args: event.args,
-        status: "executing",
-        type: toolDef ? "client" : "agent"
-      };
-      state.toolCalls.push(toolCall);
-      state.onToolCall?.(toolCall);
-      if (toolDef?.handler) {
-        try {
-          const context = {
-            args: event.args,
-            toolCallId: event.id,
-            toolName: event.name,
-            signal: void 0
-          };
-          const handlerReturn = await toolDef.handler(context);
-          result = this.#createToolResponse(event.name, handlerReturn);
-        } catch (error) {
-          const err = error;
-          console.error(`Tool handler error [${event.name}]:`, err);
-          result = { error: err.message };
-          toolCall.status = "error";
-          toolCall.result = result;
-          state.hasErrors = true;
-          if (state.mode === "multi-turn") {
-            state.runFinished = false;
-            state.hasTextResponse = false;
-            const messages = this.#buildMessageHistory(state);
-            adapter.sendToolResult(event.id, result, messages);
-          }
-          return;
-        }
-      } else {
-        result = this.#createToolResponse(event.name);
-      }
-      toolCall.status = "complete";
-      toolCall.result = result;
-      if (state.mode === "multi-turn") {
-        state.runFinished = false;
-        state.hasTextResponse = false;
-        const messages = this.#buildMessageHistory(state);
-        adapter.sendToolResult(event.id, result, messages);
-      }
-    })();
-    state.pendingToolExecutions.add(execution);
-    execution.finally(() => {
-      state.pendingToolExecutions.delete(execution);
-      this.#tryFinish(state);
-    });
-  }
-  static #tryFinish(state, onComplete) {
-    if (state.resolved || state.pendingToolExecutions.size > 0) {
-      return;
-    }
-    const shouldFinish = state.mode === "one-shot" && state.runFinished || state.mode === "multi-turn" && state.runFinished && (state.hasTextResponse || state.turns >= state.maxTurns);
-    if (!shouldFinish) {
-      return;
-    }
-    state.resolved = true;
-    state.subscriptions.unsubscribe();
-    const messages = this.#buildMessageHistory(state);
-    const finalMessage = state.currentMessage ? this.#buildSuccessResult(state) : this.#buildEmptyMessage();
-    let stoppedReason;
-    if (state.hasErrors) {
-      stoppedReason = "error";
-    } else if (state.mode === "one-shot") {
-      stoppedReason = "one-shot-complete";
-    } else if (state.turns >= state.maxTurns) {
-      stoppedReason = "max-turns";
-    } else {
-      stoppedReason = "text-response";
-    }
-    const result = {
-      messages,
-      finalMessage,
-      toolCalls: state.toolCalls,
-      turns: state.turns,
-      success: !state.hasErrors,
-      stoppedReason
-    };
-    onComplete?.(result);
-    state.resolve(result);
-  }
-  static #buildSuccessResult(state) {
-    return {
-      ...state.currentMessage,
-      status: "complete"
-    };
-  }
-  static #buildEmptyMessage() {
-    return {
-      id: generateId(),
-      role: "assistant",
-      content: "",
-      timestamp: Date.now(),
-      status: "complete"
-    };
-  }
-}
-export {
-  AgentRunner
-};

package/dist/ai-chatbot/ai-chatbot-base.d.ts

@@ -1,178 +0,0 @@
-import { LitElement, PropertyValues } from 'lit';
-import { Ref } from 'lit/directives/ref.js';
-import { AgentInfo } from '../ai-agent-info';
-import { ForgeAiChatHeaderAgentChangeEventData } from '../ai-chat-header';
-import { AiMessageThreadComponent, ForgeAiMessageThreadThumbsEventData } from '../ai-message-thread';
-import { ForgeAiAttachmentRemoveEventData } from '../ai-attachment';
-import { ForgeAiFilePickerChangeEventData, ForgeAiFilePickerErrorEventData } from '../ai-file-picker';
-import { AiPromptComponent, ForgeAiPromptCommandEventData, ForgeAiPromptSendEventData } from '../ai-prompt';
-import { ForgeAiSuggestionsEventData, Suggestion } from '../ai-suggestions';
-import { ForgeAiVoiceInputResultEvent } from '../ai-voice-input';
-import { AgentAdapter } from './agent-adapter.js';
-import { ChatbotCoreController } from '../core/chatbot-core-controller.js';
-import { Agent, ChatMessage, ClientMessageInput, ContextItem, HeadingLevel, MessageItem, SlashCommand, ThreadState, ToolDefinition } from './types.js';
-export type FeatureToggle = 'on' | 'off';
-export declare abstract class AiChatbotBase extends LitElement {
-    #private;
-    protected abstract _messageThreadRef: Ref<AiMessageThreadComponent>;
-    protected abstract _promptRef: Ref<AiPromptComponent>;
-    adapter?: AgentAdapter;
-    fileUpload: FeatureToggle;
-    maxFileSize: number;
-    acceptedFileTypes: string;
-    voiceInput: FeatureToggle;
-    placeholder: string;
-    suggestions?: Suggestion[];
-    enableReactions: boolean;
-    titleText: string;
-    headingLevel: HeadingLevel;
-    debugMode: boolean;
-    disclaimerText: string | null | undefined;
-    debugCommand: FeatureToggle;
-    exportOption: FeatureToggle;
-    clearOption: FeatureToggle;
-    agentInfo?: AgentInfo;
-    agents: Agent[];
-    selectedAgentId?: string;
-    contextItems: ContextItem[];
-    mcpAppSandboxUrl?: string;
-    /**
-     * Theme fed into an MCP-app widget's `hostContext.theme`. The chatbot's own appearance
-     * comes from Forge tokens and is unaffected. Set this whenever the app switches between
-     * light and dark: it is the signal that re-sends `theme` and the Forge-derived
-     * `styles.variables` to widgets, since token changes alone can't be detected. Absent →
-     * follows `prefers-color-scheme`.
-     */
-    mcpAppTheme?: 'light' | 'dark';
-    private _mcpAppHost;
-    /**
-     * Sends `ui/resource-teardown` to mounted MCP-app widgets (all, or only `toolCallIds`) and
-     * releases them immediately, without waiting for acks. The adapter then drops any state it
-     * holds for them (e.g. a pending model context).
-     */
-    protected _teardownMcpAppViews({ toolCallIds }?: {
-        toolCallIds?: string[];
-    }): void;
-    protected _coreController: ChatbotCoreController;
-    protected get _isStreaming(): boolean;
-    protected get _isUploading(): boolean;
-    protected get _tools(): Map<string, ToolDefinition>;
-    protected get _messageItems(): MessageItem[];
-    protected get _hasMessages(): boolean;
-    protected get _allContextItems(): ContextItem[];
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    willUpdate(changedProperties: PropertyValues<this>): void;
-    protected _onConnected(): void;
-    protected get _slashCommands(): SlashCommand[];
-    protected _handleSlashCommand(evt: CustomEvent<ForgeAiPromptCommandEventData>): void;
-    protected _handleInfo(): void;
-    protected _handleAgentChange(event: CustomEvent<ForgeAiChatHeaderAgentChangeEventData>): void;
-    protected _handleDebugToggle(): void;
-    protected _handleAttachmentRemove(evt: CustomEvent<ForgeAiAttachmentRemoveEventData>): void;
-    protected _handleContextChipRemove(evt: CustomEvent<{
-        id: string;
-        item: ContextItem;
-    }>): void;
-    protected _handlePromptContextRemove(evt: CustomEvent<{
-        id: string;
-        item: ContextItem;
-    }>): void;
-    protected _handleSend(evt: CustomEvent<ForgeAiPromptSendEventData>): Promise<void>;
-    protected _handleStop(): void;
-    protected _handleCancel(): void;
-    protected _handleCopy(evt: CustomEvent<{
-        messageId: string;
-    }>): Promise<void>;
-    protected _handleUserCopy(evt: CustomEvent<{
-        messageId: string;
-    }>): Promise<void>;
-    protected _handleUserResend(evt: CustomEvent<{
-        messageId: string;
-    }>): void;
-    protected _handleUserEdit(evt: CustomEvent<{
-        messageId: string;
-        content: string;
-    }>): void;
-    protected _handleResend(evt: CustomEvent<{
-        messageId: string;
-    }>): void;
-    protected _handleFeedback(evt: CustomEvent<ForgeAiMessageThreadThumbsEventData>, type: 'positive' | 'negative'): void;
-    protected _handleThumbsUp(evt: CustomEvent<ForgeAiMessageThreadThumbsEventData>): void;
-    protected _handleThumbsDown(evt: CustomEvent<ForgeAiMessageThreadThumbsEventData>): void;
-    protected _handleFileSelect(evt: CustomEvent<ForgeAiFilePickerChangeEventData>): void;
-    protected _handleFileError(evt: CustomEvent<ForgeAiFilePickerErrorEventData>): void;
-    protected _handleSuggestionSelect(evt: CustomEvent<ForgeAiSuggestionsEventData>): Promise<void>;
-    protected _handleVoiceInputResult(evt: CustomEvent<ForgeAiVoiceInputResultEvent>): void;
-    /**
-     * Clears all messages from the chat.
-     *
-     * This is a lower-level operation that removes message history without
-     * the semantic meaning of "starting a new conversation". For user-facing
-     * "new chat" actions, prefer {@link startNewChat} which provides
-     * conversation-level cleanup.
-     *
-     * @returns true if messages were cleared, false if prevented via event.preventDefault()
-     * @fires forge-ai-chatbot-clear - Cancelable event fired before clearing
-     */
-    clearMessages(): boolean;
-    /**
-     * Starts a new chat conversation.
-     *
-     * This clears all messages and resets the conversation to a fresh state.
-     * Use this when the user explicitly wants to begin a new conversation.
-     *
-     * Contrast with {@link clearMessages}, which fires events and can be prevented.
-     * This method does not fire events - it's meant for programmatic use.
-     * For user-initiated actions, use event handlers that fire events before calling this.
-     *
-     * Subclasses may override this to add conversation-specific cleanup like
-     * resetting thread IDs or closing panels.
-     */
-    startNewChat(): void;
-    getMessages(): ChatMessage[];
-    setMessages(messages: ChatMessage[]): void;
-    /**
-     * Inserts or upserts a client-only status message into the thread - never sent to
-     * the agent adapter and never included in the conversation history the adapter sees.
-     * Use this for host-driven UI feedback (e.g. "Your session expired", upload progress)
-     * instead of splicing {@link getMessages}/{@link setMessages} directly.
-     *
-     * Safe to call at any time, including while a response is streaming - it never
-     * finalizes or otherwise touches the in-progress response.
-     *
-     * @param message - Content and optional kind ('text' | 'info' | 'warning' | 'error' | 'success'),
-     * header, and actions. Pass the same `id` on a later call to upsert (replace) a
-     * previously added message.
-     * @returns The message id (generated if not provided).
-     */
-    addClientMessage(message: ClientMessageInput): string;
-    /**
-     * Removes a client-only message previously added via {@link addClientMessage}.
-     * No-ops if no message with that id exists. Safe to call at any time, including
-     * while a response is streaming. Removal is never automatic - call this when your
-     * host logic determines the message is no longer relevant.
-     */
-    removeClientMessage(id: string): void;
-    sendMessage(content: string, files?: File[]): Promise<void>;
-    abort(): void;
-    /**
-     * Re-sends the Forge-derived `styles.variables` to every MCP-app widget. Call after
-     * changing Forge tokens without a light/dark switch (e.g. a brand change); for light/dark,
-     * set {@link mcpAppTheme} instead.
-     */
-    refreshMcpAppStyles(): void;
-    scrollToBottom({ behavior }?: {
-        behavior?: ScrollBehavior;
-    }): Promise<void>;
-    abstract focus(): void;
-    getThreadState(): ThreadState;
-    getSelectedAgent(): Agent | undefined;
-    setThreadState(threadState: ThreadState): Promise<void>;
-    protected _dispatchHostEvent(config: {
-        type: string;
-        detail?: unknown;
-        cancelable?: boolean;
-    }): CustomEvent;
-    protected _handleExport(): void;
-}