@tylertech/forge-ai 0.10.1 → 0.11.0

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

@@ -0,0 +1,92 @@
+import { nothing, LitElement, PropertyValues, TemplateResult } 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, HeadingLevel, MessageItem, SlashCommand, ThreadState, ToolCall, ToolDefinition } from './types.js';
+export type FeatureToggle = 'on' | 'off';
+export declare abstract class AiChatbotBase extends LitElement {
+    protected abstract _messageThreadRef: Ref<AiMessageThreadComponent>;
+    protected abstract _promptRef: Ref<AiPromptComponent>;
+    adapter?: AgentAdapter;
+    fileUpload: FeatureToggle;
+    voiceInput: FeatureToggle;
+    placeholder: string;
+    suggestions?: Suggestion[];
+    enableReactions: boolean;
+    titleText: string;
+    headingLevel: HeadingLevel;
+    debugMode: boolean;
+    disclaimerText: string | null | undefined;
+    debugCommand: FeatureToggle;
+    agentInfo?: AgentInfo;
+    agents: Agent[];
+    selectedAgentId?: string;
+    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;
+    connectedCallback(): 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 get _sessionFilesTemplate(): TemplateResult | typeof nothing;
+    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;
+    clearMessages(): boolean;
+    getMessages(): ChatMessage[];
+    setMessages(messages: ChatMessage[]): void;
+    sendMessage(content: string, files?: File[]): Promise<void>;
+    abort(): void;
+    scrollToBottom({ behavior }?: {
+        behavior?: ScrollBehavior;
+    }): Promise<void>;
+    getThreadState(): ThreadState;
+    getSelectedAgent(): Agent | undefined;
+    setThreadState(threadState: ThreadState): Promise<void>;
+    protected _dispatchHostEvent(config: {
+        type: string;
+        detail?: unknown;
+        cancelable?: boolean;
+    }): CustomEvent;
+    protected _formatToolCallForExport(toolCall: ToolCall): string;
+    protected _handleExport(): void;
+}

package/dist/ai-chatbot/ai-chatbot-base.mjs

@@ -0,0 +1,467 @@
+import { LitElement, nothing, html } from "lit";
+import { property } from "lit/decorators.js";
+import { ChatbotCoreController } from "../core/chatbot-core-controller.mjs";
+import { generateId, downloadFile } from "./utils.mjs";
+var __defProp = Object.defineProperty;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = void 0;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = decorator(target, key, result) || result;
+  if (result) __defProp(target, key, result);
+  return result;
+};
+class AiChatbotBase extends LitElement {
+  constructor() {
+    super(...arguments);
+    this.fileUpload = "off";
+    this.voiceInput = "on";
+    this.placeholder = "Ask a question...";
+    this.enableReactions = false;
+    this.titleText = "AI Assistant";
+    this.headingLevel = 2;
+    this.debugMode = false;
+    this.disclaimerText = "AI can make mistakes. Always verify responses.";
+    this.debugCommand = "on";
+    this.agents = [];
+  }
+  get _isStreaming() {
+    return this._coreController?.isStreaming ?? false;
+  }
+  get _isUploading() {
+    return this._coreController?.isUploading ?? false;
+  }
+  get _tools() {
+    return this._coreController?.tools ?? /* @__PURE__ */ new Map();
+  }
+  get _messageItems() {
+    return this._coreController?.messageItems ?? [];
+  }
+  get _hasMessages() {
+    return this._coreController?.hasMessages ?? false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this._coreController = new ChatbotCoreController(this, {
+      callbacks: {
+        onRequestUpdate: () => this.requestUpdate(),
+        onScrollToBottom: () => this.scrollToBottom(),
+        onDispatchEvent: (type, detail, cancelable) => this._dispatchHostEvent({ type, detail, cancelable })
+      }
+    });
+    if (this.adapter) {
+      this._coreController.adapter = this.adapter;
+    }
+    this._onConnected();
+  }
+  willUpdate(changedProperties) {
+    if (changedProperties.has("adapter") && this._coreController) {
+      this._coreController.adapter = this.adapter;
+    }
+  }
+  _onConnected() {
+  }
+  get _slashCommands() {
+    const commands = [];
+    if (this._hasMessages) {
+      commands.push({ id: "clear", name: "Clear", group: "Conversation" });
+      commands.push({ id: "export", name: "Export", group: "Conversation" });
+    }
+    commands.push({ id: "info", name: "Info", group: "Help" });
+    if (this.debugCommand === "on") {
+      commands.push({
+        id: "debug",
+        name: `${this.debugMode ? "Disable debug mode" : "Enable debug mode"}`,
+        group: "Help"
+      });
+    }
+    return commands;
+  }
+  _handleSlashCommand(evt) {
+    const commandId = evt.detail.commandId;
+    switch (commandId) {
+      case "clear":
+        this.clearMessages();
+        break;
+      case "export":
+        this._handleExport();
+        break;
+      case "info":
+        this._handleInfo();
+        break;
+      case "debug":
+        this._handleDebugToggle();
+        break;
+    }
+  }
+  _handleInfo() {
+    this._dispatchHostEvent({ type: "forge-ai-chatbot-info" });
+  }
+  _handleAgentChange(event) {
+    const { agent, previousAgentId } = event.detail;
+    const changeEvt = this._dispatchHostEvent({
+      type: "forge-ai-chatbot-agent-change",
+      detail: { agent, previousAgentId }
+    });
+    if (!changeEvt.defaultPrevented) {
+      this.selectedAgentId = agent?.id;
+      const adapter = this._coreController.adapter;
+      if (adapter) {
+        adapter.threadId = generateId();
+      }
+      if (this._hasMessages) {
+        const agentName = agent?.name ?? this.titleText;
+        const systemMessage = {
+          id: generateId(),
+          role: "system",
+          content: `Switched to ${agentName}`,
+          timestamp: Date.now(),
+          status: "complete",
+          clientOnly: true
+        };
+        this._coreController.addMessage(systemMessage);
+      }
+    }
+  }
+  _handleDebugToggle() {
+    this.debugMode = !this.debugMode;
+  }
+  _handleAttachmentRemove(evt) {
+    const { filename } = evt.detail;
+    const pendingAttachment = this._coreController.pendingAttachments.find((a) => a.filename === filename);
+    if (pendingAttachment) {
+      this._coreController.abortFileUpload(pendingAttachment.id);
+      return;
+    }
+    const completedAttachment = this._coreController.completedAttachments.find((a) => a.filename === filename);
+    if (completedAttachment) {
+      this._coreController.removeCompletedAttachment(completedAttachment.id);
+    }
+  }
+  get _sessionFilesTemplate() {
+    const completed = this._coreController?.completedAttachments ?? [];
+    const uploading = this._coreController?.pendingAttachments ?? [];
+    const allFiles = [...uploading, ...completed];
+    if (allFiles.length === 0) {
+      return nothing;
+    }
+    return html`
+      <div class="session-files-header">Session Files (${allFiles.length})</div>
+      <div class="session-files-list">
+        ${allFiles.map(
+      (attachment) => html`
+            <forge-ai-attachment
+              .filename=${attachment.filename}
+              .size=${attachment.size}
+              ?uploading=${attachment.uploading ?? false}
+              removable
+              @forge-ai-attachment-remove=${this._handleAttachmentRemove}>
+            </forge-ai-attachment>
+          `
+    )}
+      </div>
+    `;
+  }
+  async _handleSend(evt) {
+    const pendingAttachments = [...this._coreController.pendingAttachments];
+    await this._coreController.sendMessage({
+      content: evt.detail.value,
+      timestamp: evt.detail.date.getTime(),
+      attachments: pendingAttachments
+    });
+  }
+  _handleStop() {
+    this._coreController.abort();
+  }
+  _handleCancel() {
+    this._handleStop();
+  }
+  async _handleCopy(evt) {
+    const responseId = evt.detail.messageId;
+    const responseItem = this._messageItems.find((item) => item.type === "assistant" && item.data.id === responseId);
+    if (!responseItem || responseItem.type !== "assistant") {
+      return;
+    }
+    const textContent = responseItem.data.children.filter(
+      (c) => c.type === "text"
+    ).map((c) => c.content).join("\n\n");
+    try {
+      await navigator.clipboard.writeText(textContent);
+    } catch {
+    }
+  }
+  async _handleUserCopy(evt) {
+    const messageId = evt.detail.messageId;
+    const message = this._coreController.getMessage(messageId);
+    if (!message || message.role !== "user") {
+      return;
+    }
+    try {
+      await navigator.clipboard.writeText(message.content);
+    } catch {
+    }
+  }
+  _handleUserResend(evt) {
+    const adapter = this._coreController.adapter;
+    if (!adapter) {
+      return;
+    }
+    const messageId = evt.detail.messageId;
+    const messageIndex = this._messageItems.findIndex((item) => item.type === "message" && item.data.id === messageId);
+    if (messageIndex === -1) {
+      return;
+    }
+    const responseIndex = messageIndex + 1;
+    if (responseIndex < this._messageItems.length) {
+      this._coreController.removeMessageItemsFrom(responseIndex);
+    }
+    adapter.sendMessage(this.getMessages());
+  }
+  _handleUserEdit(evt) {
+    const adapter = this._coreController.adapter;
+    if (!adapter) {
+      return;
+    }
+    const { messageId, content } = evt.detail;
+    const messageIndex = this._messageItems.findIndex((item) => item.type === "message" && item.data.id === messageId);
+    if (messageIndex === -1) {
+      return;
+    }
+    this._coreController.updateMessageContent(messageId, content);
+    const responseIndex = messageIndex + 1;
+    if (responseIndex < this._messageItems.length) {
+      this._coreController.removeMessageItemsFrom(responseIndex);
+    }
+    adapter.sendMessage(this.getMessages());
+  }
+  _handleResend(evt) {
+    const adapter = this._coreController.adapter;
+    if (!adapter) {
+      return;
+    }
+    const responseId = evt.detail.messageId;
+    const responseIndex = this._messageItems.findIndex(
+      (item) => item.type === "assistant" && item.data.id === responseId
+    );
+    if (responseIndex === -1) {
+      return;
+    }
+    this._coreController.removeMessageItemsFrom(responseIndex);
+    adapter.sendMessage(this.getMessages());
+  }
+  _handleFeedback(evt, type) {
+    this._coreController.setResponseFeedback(evt.detail.messageId, {
+      type,
+      reason: evt.detail.feedback
+    });
+    this._dispatchHostEvent({
+      type: "forge-ai-chatbot-response-feedback",
+      detail: {
+        messageId: evt.detail.messageId,
+        type,
+        feedback: evt.detail.feedback
+      }
+    });
+  }
+  _handleThumbsUp(evt) {
+    this._handleFeedback(evt, "positive");
+  }
+  _handleThumbsDown(evt) {
+    this._handleFeedback(evt, "negative");
+  }
+  _handleFileSelect(evt) {
+    const { file, timestamp } = evt.detail;
+    const fileId = this._coreController.processFileUpload(file, timestamp);
+    const callbacks = this._coreController.createFileUploadCallbacks(fileId);
+    this._dispatchHostEvent({
+      type: "forge-ai-chatbot-file-select",
+      detail: {
+        fileId,
+        file,
+        filename: file.name,
+        size: file.size,
+        mimeType: file.type,
+        timestamp,
+        ...callbacks
+      }
+    });
+  }
+  _handleFileError(evt) {
+    const errorMessage = {
+      id: generateId(),
+      role: "assistant",
+      content: evt.detail.message,
+      timestamp: Date.now(),
+      status: "error"
+    };
+    this._coreController.addMessage(errorMessage);
+  }
+  async _handleSuggestionSelect(evt) {
+    this._promptRef.value?.addToHistory(evt.detail.text);
+    await this.sendMessage(evt.detail.text);
+    this._promptRef.value?.focus();
+  }
+  _handleVoiceInputResult(evt) {
+    const { transcript } = evt.detail;
+    if (transcript && this._promptRef.value) {
+      this._promptRef.value.value = transcript;
+    }
+  }
+  clearMessages() {
+    const event = this._dispatchHostEvent({ type: "forge-ai-chatbot-clear", cancelable: true });
+    if (event.defaultPrevented) {
+      return false;
+    }
+    this._coreController.clearMessages();
+    return true;
+  }
+  getMessages() {
+    return this._coreController.getMessages();
+  }
+  setMessages(messages) {
+    this._coreController.setMessages(messages);
+  }
+  async sendMessage(content, files) {
+    if (!this._coreController.adapter) {
+      console.warn("No adapter configured.");
+      return;
+    }
+    if (files) {
+      const timestamp = Date.now();
+      for (const file of files) {
+        const fileId = this._coreController.processFileUpload(file, timestamp);
+        const callbacks = this._coreController.createFileUploadCallbacks(fileId);
+        this._dispatchHostEvent({
+          type: "forge-ai-chatbot-file-select",
+          detail: {
+            fileId,
+            file,
+            filename: file.name,
+            size: file.size,
+            mimeType: file.type,
+            timestamp,
+            ...callbacks
+          }
+        });
+      }
+    }
+    await this._coreController.sendMessage({
+      content,
+      attachments: this._coreController.pendingAttachments
+    });
+  }
+  abort() {
+    this._handleStop();
+  }
+  async scrollToBottom({ behavior } = {}) {
+    await this._messageThreadRef.value?.updateComplete;
+    await new Promise(requestAnimationFrame);
+    this._messageThreadRef.value?.scrollToBottom({ behavior });
+  }
+  getThreadState() {
+    return {
+      threadId: this._coreController.adapter?.threadId,
+      messages: this.getMessages(),
+      timestamp: Date.now(),
+      selectedAgentId: this.selectedAgentId
+    };
+  }
+  getSelectedAgent() {
+    return this.agents.find((a) => a.id === this.selectedAgentId);
+  }
+  async setThreadState(threadState) {
+    this.setMessages(threadState.messages);
+    this.selectedAgentId = threadState.selectedAgentId;
+    if (threadState.threadId && this._coreController.adapter) {
+      this._coreController.adapter.threadId = threadState.threadId;
+    }
+    await this.updateComplete;
+    const userMessages = threadState.messages.filter((msg) => msg.role === "user").map((msg) => msg.content);
+    this._promptRef.value?.setHistory(userMessages);
+    this.scrollToBottom({ behavior: "instant" });
+  }
+  _dispatchHostEvent(config) {
+    const event = new CustomEvent(config.type, {
+      detail: config.detail,
+      bubbles: true,
+      composed: true,
+      cancelable: config.cancelable ?? false
+    });
+    this.dispatchEvent(event);
+    return event;
+  }
+  _formatToolCallForExport(toolCall) {
+    const lines = [`  Tool: ${toolCall.name}`, `  Args: ${JSON.stringify(toolCall.args)}`];
+    if (toolCall.status === "error") {
+      const errorMsg = typeof toolCall.result === "object" && toolCall.result !== null && "error" in toolCall.result ? toolCall.result.error : "Unknown error";
+      lines.push(`  Error: ${errorMsg}`);
+    } else if (toolCall.result !== void 0) {
+      lines.push(`  Result: ${JSON.stringify(toolCall.result)}`);
+    }
+    return lines.join("\n");
+  }
+  _handleExport() {
+    const messages = this.getMessages();
+    if (messages.length === 0) {
+      return;
+    }
+    const chatText = messages.map((message) => {
+      const timestamp = new Date(message.timestamp).toLocaleString();
+      const role = message.role === "user" ? "You" : "Assistant";
+      let output = `[${timestamp}] ${role}:
+${message.content}
+`;
+      if (message.toolCalls?.length) {
+        output += "\n" + message.toolCalls.map((tc) => this._formatToolCallForExport(tc)).join("\n\n") + "\n";
+      }
+      return output;
+    }).join("\n");
+    const filename = `chat-history-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/:/g, "-")}.txt`;
+    downloadFile(chatText, filename, "text/plain");
+  }
+}
+__decorateClass([
+  property({ attribute: false })
+], AiChatbotBase.prototype, "adapter");
+__decorateClass([
+  property({ attribute: "file-upload" })
+], AiChatbotBase.prototype, "fileUpload");
+__decorateClass([
+  property({ attribute: "voice-input" })
+], AiChatbotBase.prototype, "voiceInput");
+__decorateClass([
+  property()
+], AiChatbotBase.prototype, "placeholder");
+__decorateClass([
+  property({ attribute: false })
+], AiChatbotBase.prototype, "suggestions");
+__decorateClass([
+  property({ type: Boolean, attribute: "enable-reactions" })
+], AiChatbotBase.prototype, "enableReactions");
+__decorateClass([
+  property({ attribute: "title-text" })
+], AiChatbotBase.prototype, "titleText");
+__decorateClass([
+  property({ attribute: "heading-level", type: Number })
+], AiChatbotBase.prototype, "headingLevel");
+__decorateClass([
+  property({ type: Boolean, attribute: "debug-mode" })
+], AiChatbotBase.prototype, "debugMode");
+__decorateClass([
+  property({ attribute: "disclaimer-text" })
+], AiChatbotBase.prototype, "disclaimerText");
+__decorateClass([
+  property({ attribute: "debug-command" })
+], AiChatbotBase.prototype, "debugCommand");
+__decorateClass([
+  property({ type: Object, attribute: false })
+], AiChatbotBase.prototype, "agentInfo");
+__decorateClass([
+  property({ attribute: false })
+], AiChatbotBase.prototype, "agents");
+__decorateClass([
+  property({ attribute: "selected-agent-id" })
+], AiChatbotBase.prototype, "selectedAgentId");
+export {
+  AiChatbotBase
+};

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

@@ -1,9 +1,8 @@
-import { LitElement, PropertyValues, TemplateResult } from 'lit';
-import { AgentInfo } from '../ai-agent-info';
-import { Suggestion } from '../ai-suggestions';
-import { ForgeAiVoiceInputResultEvent } from '../ai-voice-input';
-import { AgentAdapter } from './agent-adapter.js';
-import { Agent, ChatMessage, ForgeAiChatbotFileSelectEventData, HeadingLevel, ThreadState } from './types.js';
+import { TemplateResult } from 'lit';
+import { AiMessageThreadComponent } from '../ai-message-thread';
+import { AiPromptComponent } from '../ai-prompt';
+import { AiChatbotBase } from './ai-chatbot-base.js';
+import { Agent, ChatMessage } from './types.js';
 declare global {
     interface HTMLElementTagNameMap {
         'forge-ai-chatbot': AiChatbotComponent;
@@ -20,7 +19,6 @@ declare global {
         'forge-ai-chatbot-clear': CustomEvent<void>;
         'forge-ai-chatbot-info': CustomEvent<void>;
         'forge-ai-chatbot-file-select': CustomEvent<ForgeAiChatbotFileSelectEventData>;
-        'forge-ai-voice-input-result': CustomEvent<ForgeAiVoiceInputResultEvent>;
         'forge-ai-chatbot-file-remove': CustomEvent<ForgeAiChatbotFileRemoveEventData>;
         'forge-ai-chatbot-response-feedback': CustomEvent<ForgeAiChatbotResponseFeedbackEventData>;
         'forge-ai-chatbot-agent-change': CustomEvent<ForgeAiChatbotAgentChangeEventData>;
@@ -38,6 +36,20 @@ export interface ForgeAiChatbotToolCallEventData {
 export interface ForgeAiChatbotErrorEventData {
     error: string;
 }
+export interface ForgeAiChatbotFileSelectEventData {
+    fileId: string;
+    file: File;
+    filename: string;
+    size: number;
+    mimeType: string;
+    timestamp: number;
+    onProgress: (progress: number) => void;
+    onComplete: (result: {
+        url?: string;
+        error?: string;
+    }) => void;
+    onAbort: () => void;
+}
 export interface ForgeAiChatbotFileRemoveEventData {
     fileId: string;
 }
@@ -51,19 +63,15 @@ export interface ForgeAiChatbotAgentChangeEventData {
     previousAgentId: string | undefined;
 }
 export declare const AiChatbotComponentTagName: keyof HTMLElementTagNameMap;
-/**
- * Type for feature toggle values
- */
-export type FeatureToggle = 'on' | 'off';
 /**
  * @tag forge-ai-chatbot
  *
- * @summary A complete, self-contained AI chatbot component that implements the AG-UI protocol using an adapter pattern.
+ * @summary A complete, self-contained AI chatbot component.
  *
  * @description
  * The AI Chatbot component provides a full-featured chat interface with support for streaming responses,
  * client-side tool execution, file attachments, markdown rendering, and programmatic control.
- * It uses an adapter pattern to abstract communication, allowing for AG-UI or custom protocol implementations.
+ * It uses an adapter pattern to abstract communication, allowing for any protocol implementation.
  *
  * @slot header - Slot for custom header content
  * @slot icon - Slot for custom header icon (default: forge-ai-icon)
@@ -89,74 +97,17 @@ export type FeatureToggle = 'on' | 'off';
  * @event {CustomEvent<void>} forge-ai-chatbot-info - Fired when header info option is selected
  * @event {CustomEvent<ForgeAiChatbotResponseFeedbackEventData>} forge-ai-chatbot-response-feedback - Fired when user provides feedback on a response (thumbs up/down)
  */
-export declare class AiChatbotComponent extends LitElement {
+export declare class AiChatbotComponent extends AiChatbotBase {
     #private;
     static styles: import('lit').CSSResult;
-    adapter?: AgentAdapter;
-    fileUpload: FeatureToggle;
-    voiceInput: FeatureToggle;
-    debugCommand: FeatureToggle;
-    placeholder: string;
-    suggestions?: Suggestion[];
     showExpandButton: boolean;
     showMinimizeButton: boolean;
     expanded: boolean;
     minimizeIcon: 'default' | 'panel';
-    enableReactions: boolean;
-    agentInfo?: AgentInfo;
-    titleText: string;
-    headingLevel: HeadingLevel;
-    debugMode: boolean;
-    disclaimerText: string | null | undefined;
-    agents: Agent[];
-    selectedAgentId?: string;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    willUpdate(changedProperties: PropertyValues<this>): void;
-    /**
-     * Clears all messages from the chat history.
-     */
-    clearMessages(): void;
-    /**
-     * Gets the current message history.
-     * @returns Array of chat messages
-     */
-    getMessages(): ChatMessage[];
-    /**
-     * Sets the message history. Useful for restoring conversation state.
-     * @param messages - Array of chat messages to set
-     */
-    setMessages(messages: ChatMessage[]): void;
-    /**
-     * Gets the currently selected agent.
-     * @returns The selected agent or undefined if none selected
-     */
-    getSelectedAgent(): Agent | undefined;
-    /**
-     * Programmatically sends a message as the user.
-     * @param content - The message content to send
-     * @param files - Optional file objects to attach
-     */
+    protected _messageThreadRef: import('lit/directives/ref').Ref<AiMessageThreadComponent>;
+    protected _promptRef: import('lit/directives/ref').Ref<AiPromptComponent>;
+    protected _handleInfo(): void;
     sendMessage(content: string, files?: File[]): Promise<void>;
-    /**
-     * Aborts the current streaming response.
-     */
-    abort(): void;
-    /**
-     * Scrolls the chat interface to the bottom.
-     */
-    scrollToBottom({ behavior }?: {
-        behavior?: ScrollBehavior;
-    }): Promise<void>;
-    /**
-     * Gets the complete serializable thread state including threadId and messages.
-     * @returns ThreadState object containing threadId, messages, and timestamp
-     */
-    getThreadState(): ThreadState;
-    /**
-     * Restores thread state from a serialized ThreadState object.
-     * @param state - ThreadState object to restore
-     */
-    setThreadState(state: ThreadState): Promise<void>;
     render(): TemplateResult;
 }
+export type { FeatureToggle } from './ai-chatbot-base.js';