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

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,179 +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, ToolCall, AnyToolDefinition } 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, AnyToolDefinition>;
-    protected get _messageItems(): MessageItem[];
-    protected get _toolCalls(): ToolCall[];
-    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;
-}