@tylertech/forge-ai 0.10.0 → 0.11.0

package/dist/core/chatbot-core-controller.mjs

@@ -0,0 +1,400 @@
+import { SubscriptionManager } from "../ai-chatbot/event-emitter.mjs";
+import { FileUploadManager } from "../ai-chatbot/file-upload-manager.mjs";
+import { MessageStateController } from "../ai-chatbot/message-state-controller.mjs";
+import { generateId } from "../ai-chatbot/utils.mjs";
+class ChatbotCoreController {
+  #host;
+  #callbacks;
+  #messageStateController;
+  #fileUploadManager;
+  #adapterSubscriptions;
+  #adapter;
+  #toolsMap;
+  #executingToolHandlers = 0;
+  constructor(host, config) {
+    this.#host = host;
+    this.#callbacks = config.callbacks;
+    host.addController(this);
+  }
+  hostConnected() {
+    this.#messageStateController = new MessageStateController(this.#host, {
+      tools: this.tools,
+      onThreadSettled: () => this.#emitThreadStateChange()
+    });
+    this.#fileUploadManager = new FileUploadManager({
+      onError: (error) => {
+        this.#callbacks.onDispatchEvent("forge-ai-chatbot-error", { error });
+      },
+      onStateChange: () => {
+        this.#callbacks.onRequestUpdate();
+      }
+    });
+    if (this.#adapter) {
+      void this.#setupAdapter();
+    }
+  }
+  hostDisconnected() {
+    this.#adapterSubscriptions?.unsubscribe();
+    this.#adapter?.disconnect();
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-disconnected");
+  }
+  get adapter() {
+    return this.#adapter;
+  }
+  set adapter(value) {
+    this.#adapter = value;
+    this.#toolsMap = void 0;
+    if (value) {
+      this.#setupAdapter();
+    }
+  }
+  get messageItems() {
+    return this.#messageStateController?.messageItems ?? [];
+  }
+  get isStreaming() {
+    return (this.#adapter?.isRunning ?? false) || this.#executingToolHandlers > 0;
+  }
+  get isUploading() {
+    return this.#fileUploadManager?.isUploading ?? false;
+  }
+  get hasMessages() {
+    return this.messageItems.length > 0;
+  }
+  get tools() {
+    if (!this.#toolsMap) {
+      this.#toolsMap = new Map(this.#adapter?.getTools().map((t) => [t.name, t]) ?? []);
+    }
+    return this.#toolsMap;
+  }
+  get pendingAttachments() {
+    return this.#fileUploadManager?.pendingAttachments ?? [];
+  }
+  get completedAttachments() {
+    return this.#fileUploadManager?.completedAttachments ?? [];
+  }
+  async #setupAdapter() {
+    if (!this.#adapter || this.#adapter.isConnecting) {
+      return;
+    }
+    await this.#adapter.connect();
+    this.#adapterSubscriptions?.unsubscribe();
+    this.#adapterSubscriptions = new SubscriptionManager();
+    this.#adapterSubscriptions.add(
+      this.#adapter.onMessageStart(this.#handleMessageStart.bind(this)),
+      this.#adapter.onMessageDelta(this.#handleMessageDelta.bind(this)),
+      this.#adapter.onMessageEnd(this.#handleMessageEnd.bind(this)),
+      this.#adapter.onToolCallStart(this.#handleToolCallStart.bind(this)),
+      this.#adapter.onToolCallArgs(this.#handleToolCallArgs.bind(this)),
+      this.#adapter.onToolCallEnd(this.#handleToolCallEnd.bind(this)),
+      this.#adapter.onToolCall(this.#handleToolCall.bind(this)),
+      this.#adapter.onToolCallResult(this.#handleToolCallResult.bind(this)),
+      this.#adapter.onRunFinished(this.#handleRunFinished.bind(this)),
+      this.#adapter.onRunAborted(this.#handleRunAborted.bind(this)),
+      this.#adapter.onError(this.#handleError.bind(this)),
+      this.#adapter.onStateChange(this.#handleStateChange.bind(this))
+    );
+    this.#toolsMap = void 0;
+    this.#messageStateController?.updateConfig({ tools: this.tools });
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-connected");
+  }
+  #handleMessageStart(event) {
+    this.#messageStateController.addTextToResponse(event.messageId, "", event);
+  }
+  #handleMessageDelta(event) {
+    this.#messageStateController.appendTextDelta(event.messageId, event.delta, event);
+    this.#callbacks.onScrollToBottom();
+  }
+  #handleMessageEnd(event) {
+    this.#messageStateController.markTextComplete(event.messageId, event);
+  }
+  #handleRunFinished() {
+    this.#tryCompleteResponse();
+  }
+  #tryCompleteResponse() {
+    if (this.#executingToolHandlers > 0 || this.#adapter?.isRunning) {
+      return;
+    }
+    this.#messageStateController.tryFinalizeResponse();
+    const messages = this.getMessages();
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.role === "assistant" && lastMessage.status === "complete") {
+      this.#callbacks.onDispatchEvent("forge-ai-chatbot-message-received", { message: lastMessage });
+    }
+  }
+  #handleToolCallStart(event) {
+    const toolCall = {
+      id: event.id,
+      messageId: event.messageId,
+      name: event.name,
+      args: {},
+      argsBuffer: "",
+      status: "parsing",
+      type: this.tools.has(event.name) ? "client" : "agent"
+    };
+    this.#messageStateController.addToolCallToResponse(toolCall, event);
+  }
+  #handleToolCallArgs(event) {
+    const updates = {
+      argsBuffer: event.argsBuffer,
+      args: event.partialArgs ?? {}
+    };
+    const rawEvent = { eventType: "tool-call-args", event };
+    this.#messageStateController.updateToolCallInResponse(event.id, updates, rawEvent);
+    this.#callbacks.onScrollToBottom();
+  }
+  #handleToolCallEnd(event) {
+    const updates = {
+      args: event.args,
+      argsBuffer: void 0,
+      status: "executing"
+    };
+    const rawEvent = { eventType: "tool-call-end", event };
+    this.#messageStateController.updateToolCallInResponse(event.id, updates, rawEvent);
+  }
+  #createToolResponse(toolName, handlerReturn) {
+    if (typeof handlerReturn === "string") {
+      return handlerReturn;
+    }
+    if (handlerReturn && typeof handlerReturn === "object") {
+      return handlerReturn;
+    }
+    return `Tool '${toolName}' executed successfully`;
+  }
+  async #handleToolCall(event) {
+    let toolCall = this.#messageStateController.getToolCall(event.id);
+    if (toolCall) {
+      this.#messageStateController.updateToolCallInResponse(event.id, {
+        args: event.args,
+        status: "executing"
+      });
+    } else {
+      toolCall = {
+        id: event.id,
+        messageId: event.messageId,
+        name: event.name,
+        args: event.args,
+        status: "executing",
+        type: this.tools.has(event.name) ? "client" : "agent"
+      };
+      this.#messageStateController.addToolCallToResponse(toolCall);
+    }
+    if (toolCall?.type === "client") {
+      this.#callbacks.onDispatchEvent("forge-ai-chatbot-tool-call", {
+        toolCallId: event.id,
+        toolName: event.name,
+        arguments: event.args
+      });
+      const toolDef = this.tools.get(event.name);
+      if (toolDef?.handler) {
+        await Promise.resolve(this.#executeToolHandler(event.id, event.name, toolDef.handler, event.args));
+      } else {
+        this.#sendToolResult(event.id, this.#createToolResponse(event.name));
+      }
+    } else {
+      this.#messageStateController.updateToolCallInResponse(event.id, { status: "complete" });
+    }
+  }
+  async #executeToolHandler(toolCallId, toolName, handler, args) {
+    this.#executingToolHandlers++;
+    this.#callbacks.onRequestUpdate();
+    try {
+      const context = {
+        args,
+        toolCallId,
+        toolName,
+        signal: void 0
+      };
+      const handlerReturn = await handler(context);
+      await this.#sendToolResult(toolCallId, this.#createToolResponse(toolName, handlerReturn));
+    } catch (error) {
+      console.error(`Tool handler error [${toolName}]:`, error);
+      this.#messageStateController.updateToolCallInResponse(toolCallId, {
+        status: "error",
+        result: { error: error.message }
+      });
+      const errorMessage = {
+        id: generateId(),
+        role: "assistant",
+        content: "An unexpected error occurred.",
+        timestamp: Date.now(),
+        status: "error"
+      };
+      this.#messageStateController.addMessage(errorMessage);
+      this.#callbacks.onDispatchEvent("forge-ai-chatbot-error", { error: error.message });
+    } finally {
+      this.#executingToolHandlers--;
+      this.#tryCompleteResponse();
+      this.#callbacks.onRequestUpdate();
+    }
+  }
+  #handleError(event) {
+    const errorMessage = {
+      id: generateId(),
+      role: "assistant",
+      content: event.message,
+      timestamp: Date.now(),
+      status: "error"
+    };
+    this.#messageStateController.addMessage(errorMessage);
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-message-received", { message: errorMessage });
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-error", { error: event.message });
+  }
+  #handleRunAborted() {
+    const abortMessage = {
+      id: generateId(),
+      role: "system",
+      content: "Run cancelled",
+      timestamp: Date.now(),
+      status: "complete",
+      clientOnly: true
+    };
+    this.#messageStateController.addMessage(abortMessage);
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-message-received", { message: abortMessage });
+  }
+  #handleStateChange(_state) {
+    this.#callbacks.onRequestUpdate();
+  }
+  #handleToolCallResult(event) {
+    this.#messageStateController.completeToolCallInResponse(event.toolCallId, event.result, event);
+  }
+  async #sendToolResult(toolCallId, result) {
+    const toolCall = this.#messageStateController.getToolCall(toolCallId);
+    if (!toolCall || !this.#adapter) {
+      return;
+    }
+    this.#messageStateController.completeToolCallInResponse(toolCallId, result);
+    this.#adapter.sendToolResult(toolCallId, result, this.getMessages());
+  }
+  async sendMessage(config) {
+    if (!config.content.trim() || !this.#adapter || this.isStreaming) {
+      if (!this.#adapter) {
+        console.warn("No adapter configured.");
+      }
+      return;
+    }
+    if (!this.#fileUploadManager.canSend()) {
+      return;
+    }
+    const userMessage = {
+      id: generateId(),
+      role: "user",
+      content: config.content,
+      timestamp: config.timestamp ?? Date.now(),
+      status: "pending"
+    };
+    this.#messageStateController.addMessage(userMessage);
+    try {
+      this.#adapter.sendMessage(this.getMessages());
+      this.#messageStateController.updateMessageStatus(userMessage.id, "complete");
+    } catch (error) {
+      this.#messageStateController.updateMessageStatus(userMessage.id, "error");
+      const errorMessage = error instanceof Error ? error.message : "Failed to send message";
+      this.#callbacks.onDispatchEvent("forge-ai-chatbot-error", { error: errorMessage });
+    } finally {
+      this.#callbacks.onDispatchEvent("forge-ai-chatbot-message-sent", { message: userMessage });
+    }
+  }
+  processFileUpload(file, timestamp) {
+    const fileId = generateId();
+    this.#fileUploadManager.addAttachment(fileId, {
+      filename: file.name,
+      size: file.size,
+      mimeType: file.type,
+      timestamp
+    });
+    const callbacks = this.createFileUploadCallbacks(fileId);
+    this.#adapter?.emitFileUpload(file, callbacks);
+    return fileId;
+  }
+  createFileUploadCallbacks(fileId) {
+    return {
+      updateProgress: (progress) => {
+        this.#fileUploadManager.updateProgress(fileId, progress);
+      },
+      markComplete: (uploadedFile) => {
+        this.#fileUploadManager.markComplete(fileId, uploadedFile);
+      },
+      markError: (error) => {
+        this.#fileUploadManager.markError(fileId, error);
+      },
+      onAbort: (callback) => {
+        this.#fileUploadManager.registerOnAbort(fileId, callback);
+      }
+    };
+  }
+  abortFileUpload(fileId) {
+    this.#fileUploadManager.abort(fileId);
+  }
+  removeCompletedAttachment(attachmentId) {
+    const attachment = this.completedAttachments.find((a) => a.id === attachmentId);
+    if (attachment) {
+      this.#fileUploadManager.removeCompletedAttachment(attachmentId);
+      this.#callbacks.onRequestUpdate();
+      if (attachment.fileId) {
+        this.#adapter?.emitFileRemove(attachment.fileId, {
+          onSuccess: () => {
+          },
+          onError: (error) => {
+            console.error(`Failed to remove file ${attachment.filename}:`, error);
+          }
+        });
+      }
+    }
+  }
+  getMessage(id) {
+    return this.#messageStateController.getMessage(id);
+  }
+  getToolCall(id) {
+    return this.#messageStateController.getToolCall(id);
+  }
+  clearMessages() {
+    this.#messageStateController.clearMessages();
+    this.#fileUploadManager.clear();
+  }
+  getMessages() {
+    return this.#messageStateController.getMessages();
+  }
+  setMessages(messages) {
+    this.#messageStateController.setMessages(messages);
+  }
+  updateMessageContent(id, content) {
+    this.#messageStateController.updateMessageContent(id, content);
+  }
+  removeMessageItemsFrom(index) {
+    this.#messageStateController.removeMessageItemsFrom(index);
+  }
+  setResponseFeedback(responseId, feedback) {
+    this.#messageStateController.setResponseFeedback(responseId, feedback);
+  }
+  addMessage(message) {
+    this.#messageStateController.addMessage(message);
+  }
+  getThreadState() {
+    return {
+      threadId: this.#adapter?.threadId,
+      messages: this.getMessages(),
+      timestamp: Date.now()
+    };
+  }
+  setThreadState(state) {
+    this.setMessages(state.messages);
+    if (state.threadId && this.#adapter) {
+      this.#adapter.threadId = state.threadId;
+    }
+  }
+  abort() {
+    if (this.#adapter?.isRunning) {
+      this.#adapter.abort();
+    }
+    this.#callbacks.onRequestUpdate();
+  }
+  canSendMessage() {
+    return this.#fileUploadManager?.canSend() ?? true;
+  }
+  #emitThreadStateChange() {
+    this.#callbacks.onDispatchEvent("forge-ai-chatbot-thread-state-change");
+  }
+}
+export {
+  ChatbotCoreController
+};

package/dist/core/index.d.ts

@@ -1 +1,2 @@
 export { DragController, type DragControllerOptions } from './drag-controller.js';
+export { ChatbotCoreController, type ChatbotCoreCallbacks, type ChatbotCoreControllerConfig } from './chatbot-core-controller.js';

package/dist/core/index.mjs

@@ -1,4 +1,6 @@
 import { DragController } from "./drag-controller.mjs";
+import { ChatbotCoreController } from "./chatbot-core-controller.mjs";
 export {
+  ChatbotCoreController,
   DragController
 };

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export * from './ai-chain-of-thought';
 export * from './ai-chat-header';
 export * from './ai-chat-interface';
 export * from './ai-chatbot';
+export * from './ai-chatbot-launcher';
 export * from './ai-confirmation-prompt';
 export * from './ai-dialog';
 export * from './ai-dropdown-menu';
@@ -33,7 +34,6 @@ export * from './ai-sidebar';
 export * from './ai-sidebar-chat';
 export * from './ai-slash-command-menu';
 export * from './ai-suggestions';
-export * from './ai-suggestions';
 export * from './ai-thinking-indicator';
 export * from './ai-threads';
 export * from './ai-user-message';

package/dist/index.mjs

@@ -14,6 +14,7 @@ import { ThoughtImageComponent, ThoughtImageComponentTagName } from "./ai-chain-
 import { ThoughtDetailComponent, ThoughtDetailComponentTagName } from "./ai-chain-of-thought/thought-detail/thought-detail.mjs";
 import { AiChatHeaderComponent, AiChatHeaderComponentTagName } from "./ai-chat-header/ai-chat-header.mjs";
 import { AiChatInterfaceComponent, AiChatInterfaceComponentTagName } from "./ai-chat-interface/ai-chat-interface.mjs";
+import { AiChatbotBase } from "./ai-chatbot/ai-chatbot-base.mjs";
 import { AiChatbotComponent, AiChatbotComponentTagName } from "./ai-chatbot/ai-chatbot.mjs";
 import { AiChatbotToolCallComponent, AiChatbotToolCallComponentTagName } from "./ai-chatbot/ai-chatbot-tool-call.mjs";
 import { AgentAdapter } from "./ai-chatbot/agent-adapter.mjs";
@@ -26,6 +27,7 @@ import { MessageStateController } from "./ai-chatbot/message-state-controller.mj
 import { FileUploadManager } from "./ai-chatbot/file-upload-manager.mjs";
 import { MarkdownStreamController } from "./ai-chatbot/markdown-stream-controller.mjs";
 import { generateId, renderMarkdown } from "./ai-chatbot/utils.mjs";
+import { AiChatbotLauncherComponent, AiChatbotLauncherComponentTagName } from "./ai-chatbot-launcher/ai-chatbot-launcher.mjs";
 import { AiConfirmationPromptComponent, AiConfirmationPromptComponentTagName } from "./ai-confirmation-prompt/ai-confirmation-prompt.mjs";
 import { AiDialogComponent, AiDialogComponentTagName } from "./ai-dialog/ai-dialog.mjs";
 import { ForgeAiDropdownMenuComponent } from "./ai-dropdown-menu/ai-dropdown-menu.mjs";
@@ -78,8 +80,11 @@ export {
   AiChatHeaderComponentTagName,
   AiChatInterfaceComponent,
   AiChatInterfaceComponentTagName,
+  AiChatbotBase,
   AiChatbotComponent,
   AiChatbotComponentTagName,
+  AiChatbotLauncherComponent,
+  AiChatbotLauncherComponentTagName,
   AiChatbotToolCallComponent,
   AiChatbotToolCallComponentTagName,
   AiConfirmationPromptComponent,

package/dist/tools/ai-data-table/ai-data-table-definition.mjs

@@ -1,3 +1,4 @@
+import "../../ai-chatbot/ai-chatbot-base.mjs";
 import "../../ai-chatbot/ai-chatbot.mjs";
 import "../../ai-chatbot/ai-chatbot-tool-call.mjs";
 import "@ag-ui/client";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tylertech/forge-ai",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A library of Tyler Forge™ AI chat interface web components.",
   "license": "Apache-2.0",
   "author": "Tyler Technologies, Inc.",
@@ -39,14 +39,14 @@
     "url": "git+https://github.com/tyler-technologies-oss/forge-ai.git"
   },
   "dependencies": {
-    "@ag-ui/client": "^0.0.42",
-    "@ag-ui/core": "^0.0.42",
-    "@floating-ui/dom": "^1.7.4",
+    "@ag-ui/client": "^0.0.47",
+    "@ag-ui/core": "^0.0.47",
+    "@floating-ui/dom": "^1.7.6",
     "@lit/context": "^1.1.6",
-    "dompurify": "^3.3.1",
+    "dompurify": "^3.3.3",
     "lit": "3.3.2",
-    "marked": "^17.0.1",
-    "remend": "^1.0.1",
+    "marked": "^17.0.4",
+    "remend": "^1.3.0",
     "uuid": "^13.0.0"
   },
   "devDependencies": {
@@ -54,19 +54,19 @@
     "@esm-bundle/chai": "4.3.4-fix.0",
     "@open-wc/testing": "4.0.0",
     "@repo/prettier-config": "",
-    "@storybook/addon-a11y": "9.1.17",
-    "@storybook/addon-docs": "9.1.17",
-    "@storybook/addon-links": "9.1.17",
-    "@storybook/addon-themes": "9.1.17",
-    "@storybook/web-components-vite": "9.1.17",
+    "@storybook/addon-a11y": "9.1.20",
+    "@storybook/addon-docs": "9.1.20",
+    "@storybook/addon-links": "9.1.20",
+    "@storybook/addon-themes": "9.1.20",
+    "@storybook/web-components-vite": "9.1.20",
     "@tylertech/forge": "3.13.1",
     "@tylertech/stylelint-rules": "5.1.2",
-    "@tylertech/tyler-icons": "2.0.4",
+    "@tylertech/tyler-icons": "2.1.0",
     "@types/cssbeautify": "^0.3.5",
     "@types/dompurify": "^3.2.0",
     "@types/mocha": "10.0.10",
-    "@types/node": "25.0.3",
-    "@types/react": "^18.3.27",
+    "@types/node": "25.5.0",
+    "@types/react": "^18.3.28",
     "@types/sinon": "21.0.0",
     "@ungap/structured-clone": "^1.3.0",
     "@vueless/storybook-dark-mode": "9.0.10",
@@ -80,25 +80,25 @@
     "cssbeautify": "^0.3.1",
     "custom-element-svelte-integration": "^1.2.0",
     "custom-element-vuejs-integration": "^1.4.0",
-    "eslint": "9.39.2",
-    "glob": "13.0.0",
+    "eslint": "9.39.4",
+    "glob": "13.0.6",
     "lit-analyzer": "2.0.3",
-    "plop": "4.0.4",
-    "postcss-lit": "1.3.1",
+    "plop": "4.0.5",
+    "postcss-lit": "1.4.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-ga4": "^2.1.0",
     "remark-gfm": "4.0.1",
-    "rimraf": "6.1.2",
+    "rimraf": "6.1.3",
     "sass": "1.93.3",
-    "sinon": "21.0.1",
-    "storybook": "9.1.17",
+    "sinon": "21.0.3",
+    "storybook": "9.1.20",
     "stylelint": "16.26.1",
     "stylelint-config-standard": "39.0.1",
     "typescript": "~5.9.3",
-    "vite": "7.3.0",
+    "vite": "7.3.1",
     "vite-plugin-dts": "4.5.4",
-    "vite-tsconfig-paths": "6.0.3"
+    "vite-tsconfig-paths": "6.0.5"
   },
   "scripts": {
     "dev": "vite src/dev",